comparison src/midiEventHolder.cpp @ 22:9860abc92a30

follower has confidence measure now just using best match. Difficulty in visualising the speed likelihood fn

 #include "midiEventHolder.h"
 
 midiEventHolder::midiEventHolder(){
 //	recordedNoteOnIndex = 0;
 	
-	useTempoPrior = true;//puts sine wave round tempo
-	
-	runningInRealTime = false;
+	useTempoPrior = false;//puts sine wave round tempo
+	confidenceWeightingUsed = true;
+	
+	//there is option to use MAP estinate or integral in beayesianarraystricture class
+	
+	runningInRealTime = true;
 	bayesStruct.realTimeMode = &runningInRealTime;
+	
+	minimumMatchSpeed = 0.0;
+	maximumMatchSpeed = 2.0;
+	minimumTimeIntervalForTempoUpdate = 150;
 	
 	width = ofGetWidth();
 	height = ofGetHeight();
 	screenWidth= &width;
 	screenHeight = &height;

 	tickLocation = 0;
 	pulsesPerQuarternote = 240;
 	noteArrayIndex = 0;
 	noteMinimum = 30;
 	noteMaximum = 96;
-	
-	minimumMatchSpeed = 0.0;
-	maximumMatchSpeed = 2.0;
+
+
 
 	likelihoodWidth = 100;//using 100 is good
 	likelihoodToNoiseRatio = 0.08;//was 0.02 on 18/11/11, changing to give more weight to observations
 	
 	bayesStruct.speedLikelihoodNoise = 0.1;//was 0.05

 	
 
 	
 	speedPriorValue = 1.0;
 	
-	matchWindowWidth = 8000;//window size for matching in ms 
+	matchWindowWidth = 12000;//window size for matching in ms 
 	
 	bayesStruct.resetSize(matchWindowWidth);
 	bayesStruct.setPositionDistributionScalar(1);
 	
 	bayesStruct.resetSpeedSize(200);

 	
 	speedWindowWidthMillis = 4000;
 	speedPriorValue = 1.0;
 	noteHeight = (*screenHeight) / (float)(noteMaximum - noteMinimum);
 	
-	confidenceWeightingUsed = false;
+
 	
 	drawPhaseMode = true;
 	
 	printf("lookup index %f value %f\n", bayesStruct.prior.getLookupIndex(100, 30., 10.0), bayesStruct.prior.gaussianLookupTable[(int)bayesStruct.prior.getLookupIndex(100, 30., 10.0)]);
 }

 	
 	//played events:
 	playedEventTimes.clear();
 	playedNoteOnMatrix.clear();
 	matchMatrix.clear();
+	bestMatchFound.clear();
 }
 
 void midiEventHolder::printNotes(){
 	printf("RECORDED MATRIX\n");
 	for (int i = 0;i < recordedNoteOnMatrix.size();i++){

 double midiEventHolder::getEventTimeMillis(double ticks){
 	return (period * ticks / (double) pulsesPerQuarternote);
 }
 
 void midiEventHolder::newNoteOnEvent(int pitch, int velocity, double timePlayed){
+	tempoSpeedString = "";
 	
 	//MOVE INTO BAYESSTRUCT?? XXX
 	//bayesStruct.copyPriorToPosterior();
 	//why was this here??
 	bayesStruct.prior.copyFromDynamicVector(bayesStruct.posterior);//try the otehr way

 	int numberOfMatchesFound = findLocalMatches(pitch);
 	setMatchLikelihoods(numberOfMatchesFound);
 	bayesStruct.calculatePosterior();
 	
 	//having found matches we have matches for new note and matches for previous notes
-	//if (!confidenceWeightingUsed)
+	if (!confidenceWeightingUsed)
 	findLocalTempoPairs();
-	//else
-	//findLocalTempoPairsWeightedForConfidence();
+	else
+	findLocalTempoPairsWeightedForConfidence();
 	
 	//bayesStruct.addGaussianNoiseToSpeedPosterior(10);
 	 
 }
 

 	while (startIndex < recordedEventTimes.size() && recordedEventTimes[startIndex] < endTime){
 		if (recordedNoteOnMatrix[startIndex][1] == notePitch){
 			
 			matchesFound.push_back(startIndex);
 			v.push_back(startIndex);
+			//so startIndex is registered as a match
+			
 			double eventConfidence = bayesStruct.posterior.getValueAtMillis(recordedEventTimes[startIndex]);
 				if (eventConfidence > minimumConfidence){
 					minimumConfidence = eventConfidence;
 					bestMatchIndex = startIndex;
 				}

 //	printf("%i MATCHES TO Note %i found\n", (int)matchesFound.size(), notePitch);
 	int size = matchesFound.size();
 		if (size > 0)
 		noteOnMatches[bestMatchIndex] = true;
 	
-	v.insert(v.begin() , (int)size);
+	v.insert(v.begin() , (int)size);//at beginning, we list how many matches there are that we have found
 	d.insert(d.begin() , (double)size);
 	
 	//v.push_back(size);
 	//d.push_back(size);
 	//for (int i = 0;i < matchesFound.size()+1;i++){

 	 
 	
 	matchMatrix.push_back(v);
 	matchConfidence.push_back(d);
 	
+	//bringing in way to list only the best matches and use these in tempo process
+	bestMatchFound.push_back(bestMatchIndex);
+	
 	printf("BEST MATCH TO note %i, start time %i, endtime %i, time %i is recorded time %i, confidence %0.2f\n", notePitch, startTime, endTime, (int) recordedEventTimes[bestMatchIndex], minimumConfidence);
 	
 	return size;
 }
 

 		
 		while (previousIndex >= 0 && playedEventTimes[previousIndex] + speedWindowWidthMillis > playedEventTimes[currentPlayedIndex]) {
 			double playedTimeDifference = playedEventTimes[currentPlayedIndex] - playedEventTimes[previousIndex];
 			
 			for (int k = 0;k < matchMatrix[previousIndex][0];k++){
+				
 				int recordedPreviousIndex = matchMatrix[previousIndex][k+1];
 				
-				
 				double recordedTimeDifference = recordedEventTimes[recordedCurrentIndex] - recordedEventTimes[recordedPreviousIndex];
 				
 				
 				//we want the speed of the recording relative to that of the playing live
 				
 				double speedRatio = recordedTimeDifference / playedTimeDifference;
-				if (speedRatio <= maximumMatchSpeed && speedRatio >= minimumMatchSpeed){
+				if (recordedTimeDifference > minimumTimeIntervalForTempoUpdate &&
+					speedRatio <= maximumMatchSpeed && speedRatio >= minimumMatchSpeed){
+					
 					//adding in a prior that prefers 1
 					double priorWeighting = 1;
 					if (useTempoPrior)
 						priorWeighting = sin(speedRatio * PI/2);
 					

 					
 					//bayesStruct.updateTempoDistribution(speedRatio, 0.1);//second paramter is confidence in the match
 					double amount =	(1-bayesStruct.speedLikelihoodNoise)/10;
 					amount *= priorWeighting;
 					bayesStruct.updateTempoLikelihood(speedRatio, amount);
+					tempoSpeedString += ofToString(recordedPreviousIndex) + "  "+ ofToString(speedRatio, 2) + "  "+ofToString(amount, 2) += " \n";
 					needToUpdate = true;
 				}
 				//		printf("\n");	
 			}
 			

 }
 
 
 void midiEventHolder::findLocalTempoPairsWeightedForConfidence(){
 	bool needToUpdate = false;
+	
+	//adapted this to just use the best match for each note
 	
 	int currentPlayedIndex = playedNoteOnMatrix.size()-1;
 	//	printf("played %i : %i, vel %i\n", currentPlayedIndex, playedNoteOnMatrix[currentPlayedIndex][0], playedNoteOnMatrix[currentPlayedIndex][1]);
 	//	printMatchesFound();
 	//	printMatchMatrix();
 	//	printf("possible notes \n");
 	
 	bayesStruct.setLikelihoodToConstant();
 	
-	for (int i = 0;i < matchMatrix[currentPlayedIndex][0];i++){
-		//iterate through the recently matched events - even dodgy matches included
-		//size, index of match0, index of match1, ....
-		int recordedCurrentIndex = matchMatrix[currentPlayedIndex][i+1];
-		
-		double currentMatchConfidence = matchConfidence[currentPlayedIndex][i+1];//new confidence
-		
+	int recordedCurrentIndex = bestMatchFound[currentPlayedIndex];
+	//we only look at intervals between the current best match and other recent best matched notes
+	//that is the difference in confidence method
+	
+	
+		printf("BEST MATCH FOUND for index %i is %i ", currentPlayedIndex, bestMatchFound[currentPlayedIndex]);
+	
 		int previousIndex = currentPlayedIndex-1;
 		
+		//withing speedwindow i.e. 4 seconds
 		while (previousIndex >= 0 && playedEventTimes[previousIndex] + speedWindowWidthMillis > playedEventTimes[currentPlayedIndex]) {
 			double playedTimeDifference = playedEventTimes[currentPlayedIndex] - playedEventTimes[previousIndex];
-			
-			for (int k = 0;k < matchMatrix[previousIndex][0];k++){
-				int recordedPreviousIndex = matchMatrix[previousIndex][k+1];
-				
-				double previousMatchConfidence = matchConfidence[previousIndex][k+1];
-				
-				
-				double recordedTimeDifference = recordedEventTimes[recordedCurrentIndex] - recordedEventTimes[recordedPreviousIndex];
+
+			int recordedPreviousIndex = bestMatchFound[previousIndex];
+			
+			double recordedTimeDifference = recordedEventTimes[recordedCurrentIndex] - recordedEventTimes[recordedPreviousIndex];
 				
 				
 				//we want the speed of the recording relative to that of the playing live
 				
 				double speedRatio = recordedTimeDifference / playedTimeDifference;
-				if (speedRatio <= maximumMatchSpeed && speedRatio >= minimumMatchSpeed){
-					
-					 printf("(%i)", matchMatrix[currentPlayedIndex][i+1]);
+				if (recordedTimeDifference > minimumTimeIntervalForTempoUpdate
+					&& speedRatio < maximumMatchSpeed && speedRatio > minimumMatchSpeed){
+					
+					 printf("(%i)", previousIndex);
 					 printf("[%i] :: ", recordedPreviousIndex);
-					printf(" conf %f & %f ", currentMatchConfidence, previousMatchConfidence);
+				//	printf(" conf %f & %f ", currentMatchConfidence, previousMatchConfidence);
 					printf(" rec{%f} vs play(%f) ", recordedTimeDifference, playedTimeDifference);
 					 printf("update on speed ratio %f\n", speedRatio);
 					 
 					//	matchString += " speed: "+ofToString(speedRatio, 3);
 					//	commented for debug
-					double weighting = previousMatchConfidence * currentMatchConfidence ;
-					double amount =	(1-bayesStruct.speedLikelihoodNoise)*weighting/10;
+					
+					
+					double priorWeighting = 1;
+					
+					if (useTempoPrior)
+						priorWeighting = sin(speedRatio * PI/2);//adding in a prior that prefers 1.0 speed
+					
+					
+				//	double weighting = previousMatchConfidence * currentMatchConfidence ;
+					double amount =	(1-bayesStruct.speedLikelihoodNoise)*priorWeighting/16;//was 9
 					bayesStruct.updateTempoLikelihood(speedRatio, amount);//second paramter is confidence in the match
+					
+					tempoSpeedString += ofToString(recordedCurrentIndex) + " :: " + ofToString(recordedPreviousIndex);
+					tempoSpeedString += "  " + ofToString(recordedTimeDifference)+ "  " + ofToString(speedRatio, 2) + "  "+ofToString(amount, 2) += " \n";
+					
 					needToUpdate = true;
 				}
 				//		printf("\n");	
+			
+			
+			previousIndex--;
+		}//end while previousindex countdown
+	
+	if (needToUpdate)
+		bayesStruct.updateTempoDistribution();
+	//printf("current speed is %f\n", bayesStruct.relativeSpeedPosterior.getIndexInRealTerms(bayesStruct.relativeSpeedPosterior.MAPestimate));
+}
+
+/*
+void midiEventHolder::findLocalTempoPairsWeightedForConfidence(){
+	bool needToUpdate = false;
+	
+	//adapted this to just use the best match for each note
+	
+	int currentPlayedIndex = playedNoteOnMatrix.size()-1;
+	//	printf("played %i : %i, vel %i\n", currentPlayedIndex, playedNoteOnMatrix[currentPlayedIndex][0], playedNoteOnMatrix[currentPlayedIndex][1]);
+	//	printMatchesFound();
+	//	printMatchMatrix();
+	//	printf("possible notes \n");
+	
+	bayesStruct.setLikelihoodToConstant();
+	
+	for (int i = 0;i < matchMatrix[currentPlayedIndex][0];i++){
+		
+		//iterate through the recently matched events - even dodgy matches included
+		//size, index of match0, index of match1, ....
+		int recordedCurrentIndex = matchMatrix[currentPlayedIndex][i+1];
+		
+		double currentMatchConfidence = matchConfidence[currentPlayedIndex][i+1];//new confidence
+		
+		int previousIndex = currentPlayedIndex-1;
+		
+		while (previousIndex >= 0 && playedEventTimes[previousIndex] + speedWindowWidthMillis > playedEventTimes[currentPlayedIndex]) {
+			double playedTimeDifference = playedEventTimes[currentPlayedIndex] - playedEventTimes[previousIndex];
+			
+			//			for (int k = 0;k < matchMatrix[previousIndex][0];k++)
+			int recordedPreviousIndex = bestMatchFound[previousIndex];//matchMatrix[previousIndex][k+1];
+			
+			//double previousMatchConfidence = matchConfidence[previousIndex][k+1];
+			
+			
+			double recordedTimeDifference = recordedEventTimes[recordedCurrentIndex] - recordedEventTimes[recordedPreviousIndex];
+			
+			
+			//we want the speed of the recording relative to that of the playing live
+			
+			double speedRatio = recordedTimeDifference / playedTimeDifference;
+			if (speedRatio <= maximumMatchSpeed && speedRatio >= minimumMatchSpeed){
+				
+				printf("(%i)", matchMatrix[currentPlayedIndex][i+1]);
+				printf("[%i] :: ", recordedPreviousIndex);
+				//	printf(" conf %f & %f ", currentMatchConfidence, previousMatchConfidence);
+				printf(" rec{%f} vs play(%f) ", recordedTimeDifference, playedTimeDifference);
+				printf("update on speed ratio %f\n", speedRatio);
+				
+				//	matchString += " speed: "+ofToString(speedRatio, 3);
+				//	commented for debug
+				
+				
+				double priorWeighting = 1;
+				
+				if (useTempoPrior)
+					priorWeighting = sin(speedRatio * PI/2);//adding in a prior that prefers 1.0 speed
+				
+				
+				//	double weighting = previousMatchConfidence * currentMatchConfidence ;
+				double amount =	(1-bayesStruct.speedLikelihoodNoise)*priorWeighting/10;
+				bayesStruct.updateTempoLikelihood(speedRatio, amount);//second paramter is confidence in the match
+				tempoSpeedString += ofToString(recordedPreviousIndex) + "  " + ofToString(speedRatio, 2) + "  "+ofToString(amount, 2) += " \n";
+				
+				needToUpdate = true;
 			}
+			//		printf("\n");	
+			
 			
 			previousIndex--;
 		}//end while previousindex countdown
 	}//end for loop through possible current matches
 	
 	if (needToUpdate)
 		bayesStruct.updateTempoDistribution();
 	//printf("current speed is %f\n", bayesStruct.relativeSpeedPosterior.getIndexInRealTerms(bayesStruct.relativeSpeedPosterior.MAPestimate));
 }
-
+*/
 
 
 void midiEventHolder::updatePlayPosition(){
 	
 	//in actual fact if we are changing the speed of the play position 

 		while (minNoteIndexToPrint > 0 && recordedNoteOnMatrix[minNoteIndexToPrint][0] > numberOfScreensIn*ticksPerScreen)//&& minNoteIndexToPrint < size 
 			minNoteIndexToPrint--;
 		
 		for (int tmpIndex = max(0,minNoteIndexToPrint);tmpIndex < min(maxNoteIndexToPrint, (int)recordedNoteOnMatrix.size());tmpIndex++){
 			
+			ofSetColor(255,255,255);
 			if (checkIfMatchedNote(tmpIndex))
-				ofSetColor(0,0,255);
+				ofSetColor(100,100,100);//0,0,255);
 			else if(noteOnMatches[tmpIndex]){
-				ofSetColor(255,0,255);
-			}else{
-				ofSetColor(255,255,255);
+				ofSetColor(255,0,255);//dark grey
 			}
-			
+			else{
+				ofSetColor(255,255,255);//255,255,255);
+			}
+			
+			//ofSetColor(255,255,255);
 			if (tmpIndex == bestMatchIndex)
 				ofSetColor(255,0,0);//best recent match is in red
 			
 			//		 XXX replace ofgetwidth below
 			//if (tmpIndex >= 0 && tmpIndex < size)

 		int xLocation;// = getLocationFromTicks(tickLocation);
 		//	ofLine(xLocation, 0, xLocation, (*screenHeight));
 		
 		//orange line at best estimate
 		xLocation = getLocationFromMillis(bayesStruct.bestEstimate);
-		ofSetColor(250,100,0);
+		ofSetColor(80,80,80);//250,100,0);
 		ofLine(xLocation, 0, xLocation, (*screenHeight));
 		
 		xLocation = getLocationFromMillis(bayesStruct.tmpBestEstimate);
-		ofSetColor(250,100,0);
+		ofSetColor(150,150,150);//250,100,0);
 		ofLine(xLocation, 0, xLocation, (*screenHeight));
 		
 		
 		//lines where matching window start and end are 
-		ofSetColor(0,100,255);
+		ofSetColor(0);//0,100,255);
 		xLocation = getLocationFromMillis(windowStartTime);
 		ofLine(xLocation, 0, xLocation, (*screenHeight));
 		xLocation = getLocationFromMillis(windowStartTime+matchWindowWidth);
 		ofLine(xLocation, 0, xLocation, (*screenHeight));
 		
 		
 		int maxSize = recordedNoteOnMatrix[size-1][0];
 		
+		ofDrawBitmapString(tempoSpeedString, 20, 20);
 	/*	string indexString = "num screens in "+ofToString(numberOfScreensIn)+"; min index to print "+ofToString(minNoteIndexToPrint)+", max index to print "+ofToString(maxNoteIndexToPrint);
 		indexString += " size "+ofToString(size)+" tick loc "+ofToString(tickLocation)+" max size "+ofToString(maxSize);
 		ofDrawBitmapString(indexString, 20, 40);
 	 */
 	}