comparison src/midiEventHolder.cpp @ 24:5a11b19906c7

hackday code is added.

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

 //	double timeDifference = ofGetElapsedTimeMillis() - bayesStruct.lastEventTime; 
 	double timeDifference = timePlayed - bayesStruct.lastEventTime; 
 	
 	
 	
-	printf("note %i played at %f and last event %f time difference %f and current best estmate %f\n", pitch, timePlayed, bayesStruct.lastEventTime, timeDifference, bayesStruct.bestEstimate);
+	//printf("note %i played at %f and last event %f time difference %f and current best estmate %f\n", pitch, timePlayed, bayesStruct.lastEventTime, timeDifference, bayesStruct.bestEstimate);
+
 	//addnoise to the tempo distribution
 	//bayesStruct.decaySpeedDistribution(timeDifference);
 	if (timeDifference > 50){
 	bayesStruct.addGaussianNoiseToSpeedPosterior(timeDifference * 10 / 100.);
 //	bayesStruct.addTriangularNoiseToSpeedPosterior(timeDifference * 10 / 100.);

 	//here we find the matches to the new note within appropriate range
 		
 	matchString = "";
 	
 	windowStartTime = max(0.0,(bayesStruct.bestEstimate - matchWindowWidth/2));//was playPositionInMillis
-	cout << "best estimate is " << bayesStruct.bestEstimate << endl;
+//	cout << "best estimate is " << bayesStruct.bestEstimate << endl;
 	int numberOfMatches = findMatch(notePitch, windowStartTime, windowStartTime + matchWindowWidth);
 
 	
-	matchString += " pitch: "+ofToString(notePitch)+" matches "+ofToString(numberOfMatches)+" win start "+ofToString(windowStartTime);	
+	//matchString += " pitch: "+ofToString(notePitch)+" matches "+ofToString(numberOfMatches)+" win start "+ofToString(windowStartTime);	
 	
 	return numberOfMatches;
 	
 	
 }

 				}
 			d.push_back(eventConfidence);
 			
 			double confidence = eventConfidence;//bayesStruct.posterior.getValueAtMillis(mouseX);
 	//																   recordedEventTimes[startIndex]);
-			matchString += "["+ofToString(startIndex)+"] = "+ofToString(confidence, 3)+" .";
+	//		matchString += "["+ofToString(startIndex)+"] = "+ofToString(confidence, 3)+" .";
 			
 			if (abs(recordedEventTimes[startIndex] - bayesStruct.bestEstimate) < tmpError){
 				//record the error between expected and observed times
 				tmpError = abs(recordedEventTimes[startIndex] - bayesStruct.bestEstimate);
 				minimumMatchError = tmpError;//recordedEventTimes[startIndex] - bayesStruct.bestEstimate;

 	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);
+//	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;
 }
 
 bool midiEventHolder::checkIfMatchedNote(const int& tmpIndex){

 					
 					//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";
+				//	tempoSpeedString += ofToString(recordedPreviousIndex) + "  "+ ofToString(speedRatio, 2) + "  "+ofToString(amount, 2) += " \n";
 					needToUpdate = true;
 				}
 				//		printf("\n");	
 			}
 			

 }
 
 
 void midiEventHolder::findLocalTempoPairsWeightedForConfidence(){
 	bool needToUpdate = false;
+	
+	DoubleVector speedIntervalsFound;
 	
 	//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]);

 	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]);
+		//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 speedRatio = recordedTimeDifference / playedTimeDifference;
 				if (recordedTimeDifference > minimumTimeIntervalForTempoUpdate
 					&& speedRatio < maximumMatchSpeed && speedRatio > minimumMatchSpeed){
 					
-					 printf("(%i)", previousIndex);
+			/*		 printf("(%i)", previousIndex);
 					 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;

 						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";
+					
+					speedIntervalsFound.push_back(speedRatio);
+		//			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 (speedIntervalsFound.size() > 0){
+		double amount = (1 - bayesStruct.speedLikelihoodNoise) / speedIntervalsFound.size();
+		for (int i = 0;i < speedIntervalsFound.size();i++)
+		bayesStruct.updateTempoLikelihood(speedIntervalsFound[i], amount);
+	}
+	
 	
 	if (needToUpdate)
 		bayesStruct.updateTempoDistribution();
 	//printf("current speed is %f\n", bayesStruct.relativeSpeedPosterior.getIndexInRealTerms(bayesStruct.relativeSpeedPosterior.MAPestimate));
 }

 		ofLine(xLocation, 0, xLocation, (*screenHeight));
 		
 		
 		int maxSize = recordedNoteOnMatrix[size-1][0];
 		
-		ofDrawBitmapString(tempoSpeedString, 20, 20);
+	//	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);
 	 */
 	}	

 
 void midiEventHolder::reorderMatrixFromNoteTimes(IntMatrix& noteOnMatrix){
 	double currentTime = -19999.;
 	for (int i = 0;i < noteOnMatrix.size();i++){
 		int nextIndex = getIndexOfMinimumAboveTime(currentTime, noteOnMatrix);
-		cout << "index of min time " << currentTime << " is " << nextIndex << " at time " <<  noteOnMatrix[nextIndex][0] << endl;
-	//	cout << "next index " << nextIndex << " time " << noteOnMatrix[nextIndex][0] << endl; 
+	//	cout << "index of min time " << currentTime << " is " << nextIndex << " at time " <<  noteOnMatrix[nextIndex][0] << endl;
+	
 		if (nextIndex >= 0 && nextIndex > i &&	noteOnMatrix[nextIndex][0] < noteOnMatrix[i][0] ){
 			//which it should be
-			cout << " index " << nextIndex << " at time " << noteOnMatrix[nextIndex][0] << " swaps with inex " << i << " at time  " << noteOnMatrix[i][0] << endl; 
+	//		cout << " index " << nextIndex << " at time " << noteOnMatrix[nextIndex][0] << " swaps with inex " << i << " at time  " << noteOnMatrix[i][0] << endl; 
 			noteOnMatrix[i].swap(noteOnMatrix[nextIndex]);
 			currentTime = noteOnMatrix[i][0];
 		}
 		
 	}