comparison src/BayesianArrayStructure.cpp @ 9:75dcd1308658

looked at tempo process, likelihood function changed and improved. Now drawing using constrained vector function. Good working version.

 	prior.createVector(1);
 	likelihood.createVector(1);
 	posterior.createVector(1);
 
 	speedPriorValue = 1.0;
+	speedEstimate = speedPriorValue;
 	
 	lastEventTime = ofGetElapsedTimeMillis();
 	
 	/*
 	 tmpPrior.createVector(240);

 	//relativeSpeedPosterior.addToIndex(50, 1);
 	relativeSpeedPosterior.renormalise();
 	relativeSpeedPosterior.getMaximum();
 	
 	setSpeedPrior(speedPriorValue);
+	speedEstimate = speedPriorValue;
 	
 	prior.zero();
 	posterior.zero();
 //	posterior.offset = - 200;
 //	posterior.addGaussianShape(200, 40, 1);

 void BayesianArrayStructure::updateTmpBestEstimate(const double& timeDifference){
 	//input is the time since the start of playing
 	
 //	double timeDiff = ofGetElapsedTimeMillis() - lastEventTime;//lastBestEstimateUpdateTime;
 	
-	tmpBestEstimate = posterior.getIndexInRealTerms(posterior.MAPestimate) + timeDifference*relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);
+	tmpBestEstimate = posterior.getIndexInRealTerms(posterior.MAPestimate) + timeDifference*relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.integratedEstimate);
 	// 
-	printf("tmp best %f and best %f time diff %f posterior MAP %f at speed %f\n", tmpBestEstimate, bestEstimate, timeDifference, posterior.getIndexInRealTerms(posterior.MAPestimate), relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate));
+	//printf("tmp best %f and best %f time diff %f posterior MAP %f at speed %f\n", tmpBestEstimate, bestEstimate, timeDifference, posterior.getIndexInRealTerms(posterior.MAPestimate), relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.integratedEstimate));
 	//lastBestEstimateUpdateTime = ofGetElapsedTimeMillis();
 }
 	
 void BayesianArrayStructure::updateBestEstimate(){
 //	double timeDiff = ofGetElapsedTimeMillis() - lastEventTime;//
 	double timeDiff = ofGetElapsedTimeMillis() - lastBestEstimateUpdateTime;
-	bestEstimate = posterior.getIndexInRealTerms(posterior.MAPestimate) + timeDiff*relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);
+	
+	double speedEstimate = relativeSpeedPosterior.getIntegratedEstimate();
+	speedEstimate = relativeSpeedPosterior.getIndexInRealTerms(speedEstimate);
+	//relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate)
+	bestEstimate = posterior.getIndexInRealTerms(posterior.MAPestimate) + timeDiff*speedEstimate;
 	
 //	bestEstimate = tmpBestEstimate;
 }
 
 void BayesianArrayStructure::calculatePosterior(){

 
 }
 
 void BayesianArrayStructure::complexCrossUpdate(const double& timeDifferenceInPositionVectorUnits){
 	int distanceMoved, newPriorIndex;
+	
+	double speedValue = relativeSpeedPosterior.offset;
+	
 	for (int i = 0;i < relativeSpeedPosterior.arraySize;i++){
 		
-		double speedValue = relativeSpeedPosterior.getIndexInRealTerms(i);//so for scalar 0.01, 50 -> speed value of 0.5
+	//	double speedValue = relativeSpeedPosterior.getIndexInRealTerms(i);//so for scalar 0.01, 50 -> speed value of 0.5
 		
 		//so we have moved 
 		distanceMoved = round(timeDifferenceInPositionVectorUnits * speedValue);//round the value
 	
 		if (relativeSpeedPosterior.array[i] != 0){
 			double speedContribution = relativeSpeedPosterior.array[i];
 			//	printf("speed [%i] gives %f moved %i in %f units \n", i, speedValue, distanceMoved, timeDifferenceInPositionVectorUnits);
 			
+			newPriorIndex = posterior.offset - prior.offset + distanceMoved;
+			
 			for (int postIndex = 0;postIndex < posterior.arraySize;postIndex++){
 				//old posterior contributing to new prior
-				newPriorIndex = postIndex + posterior.offset - prior.offset + distanceMoved;
+			//	newPriorIndex = postIndex + posterior.offset - prior.offset + distanceMoved;
+				
 				if (newPriorIndex >= 0 && newPriorIndex < prior.arraySize){
 					prior.addToIndex(newPriorIndex, posterior.array[postIndex]*speedContribution);
 				}
 				
-			}
+				newPriorIndex++;//optimised code - the commented line above explains how this works
+			}//end for
+			
 			
 		}//if not zero
+		speedValue += relativeSpeedPosterior.scalar;
+		//optimised line
+		//as we wanted:
+		//	double speedValue = relativeSpeedPosterior.getIndexInRealTerms(i);//so for scalar 0.01, 50 -> speed value of 0.5
 	}//end speed
 }
 
 
 
 void BayesianArrayStructure::translateByMaximumSpeed(const double& timeDifferenceInPositionVectorUnits){
+
 	int distanceMoved, newPriorIndex;
-
-		
-		double speedValue = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);//using max value only
+	
+	double speedValue = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.integratedEstimate);
 	//so for scalar 0.01, 50 -> speed value of 0.5
-	double speedContribution = relativeSpeedPosterior.array[relativeSpeedPosterior.MAPestimate];
+	double speedContribution = relativeSpeedPosterior.array[relativeSpeedPosterior.integratedEstimate];
 		//so we have moved 
 		distanceMoved = round(timeDifferenceInPositionVectorUnits * speedValue);//round the value
 					//	printf("speed [%i] gives %f moved %i in %f units \n", i, speedValue, distanceMoved, timeDifferenceInPositionVectorUnits);
 			
 			for (int postIndex = 0;postIndex < posterior.arraySize;postIndex++){

 	relativeSpeedPosterior.copyFromDynamicVector(tmpPosteriorForStorage);											
 }
 
 void BayesianArrayStructure::calculateNewPriorOffset(const double& timeDifference){
 	
-	double maxSpeed = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);
+	double maxSpeed = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.integratedEstimate);
 	//	printf("Maxspeed is %f\n", maxSpeed);
 	
 	double priorMax = posterior.getMaximum();
 	double distanceTravelled = maxSpeed * (timeDifference / prior.scalar);
 	double newMaxLocation = posterior.MAPestimate + distanceTravelled;

 	// commented for the moment
 	 double relativeAmount = max(1.0, timeDifference/1000.);
 //	printf("decay %f around %i \n", timeDifference, relativeSpeedPosterior.MAPestimate);
 	relativeAmount *= speedDecayAmount;
 	relativeSpeedPosterior.renormalise();
-	relativeSpeedPosterior.addGaussianShape(relativeSpeedPosterior.MAPestimate, speedDecayWidth, relativeAmount);
+	relativeSpeedPosterior.addGaussianShape(relativeSpeedPosterior.integratedEstimate, speedDecayWidth, relativeAmount);
 	
 	relativeSpeedPosterior.renormalise();
 	double newMax = relativeSpeedPosterior.getMaximum();
 	
 	//old code

 	
 
 	
 }
 
-void BayesianArrayStructure::updateTempoDistribution(const double& speedRatio, const double& matchFactor){
+void BayesianArrayStructure::setLikelihoodToConstant(){
+	//set new likelihood
+	relativeSpeedLikelihood.zero();
+	relativeSpeedLikelihood.addConstant(speedLikelihoodNoise);
+}
+
+
+void BayesianArrayStructure::updateTempoLikelihood(const double& speedRatio, const double& matchFactor){
+	
 	//speedratio is speed of played relative to the recording
 	
 	double index = relativeSpeedLikelihood.getRealTermsAsIndex(speedRatio);
-//	printf("\nindex of likelihood would be %f\n", index);
-	if (index >= 0 && index < relativeSpeedPrior.length){
-		//then we can do update
-		
-		//set new likelihood
-		relativeSpeedLikelihood.zero();
-		relativeSpeedLikelihood.addConstant(speedLikelihoodNoise);
-		
-	relativeSpeedLikelihood.addGaussianShape(index , 5, 0.5*matchFactor);
-	
+	//	printf("index of likelihood would be %f for ratio %f\n", index, speedRatio);
+	if (index >= 0 && index < relativeSpeedPrior.length){	
+		relativeSpeedLikelihood.addGaussianShape(index , 5, matchFactor);
+	}
+}
+	
+	
+void BayesianArrayStructure::updateTempoDistribution(){
 
 	//copy posterior to prior
 	relativeSpeedPrior.copyFromDynamicVector(relativeSpeedPosterior);
 
 	//update

 
 	//normalise
 	relativeSpeedPosterior.renormalise();
 		
 	relativeSpeedPosterior.getMaximum();	
-	}//end if within range
-	
-
-}
-
-
-void BayesianArrayStructure::setFlatTempoLikelihood(){	//set new likelihood
-	relativeSpeedLikelihood.zero();
-	relativeSpeedLikelihood.addConstant(0.3);
-}
-
-void BayesianArrayStructure::updateTempoLikelihood(const double& speedRatio, const double& matchFactor){
-	
-	double index = relativeSpeedLikelihood.getRealTermsAsIndex(speedRatio);
-
-	if (index >= 0 && index < relativeSpeedPrior.length){
-		relativeSpeedLikelihood.addGaussianShape(index , 5, 0.5);//*matchFactor);
-	}
+	
+	relativeSpeedPosterior.updateIntegratedEstimate();
+	speedEstimate = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.integratedEstimate);
 }
 
 
 void BayesianArrayStructure::calculateTempoUpdate(){
 	//copy posterior to prior

 	
 }
 
 
 void BayesianArrayStructure::drawTempoArrays(){
-	ofSetColor(0,255,255);
-	relativeSpeedPrior.drawVector(0, relativeSpeedPrior.arraySize);
+	ofSetColor(0,0,255);
+//	relativeSpeedPrior.drawVector(0, relativeSpeedPrior.arraySize);
 	
 	ofSetColor(255,0,255);
 	relativeSpeedLikelihood.drawVector(0, relativeSpeedLikelihood.arraySize);
-	
-	ofSetColor(255,255,0);
+//	relativeSpeedLikelihood.drawConstrainedVector(0, 199, 0, 1000);// relativeSpeedLikelihood.arraySize);	
+	ofSetColor(255,0,0);
 	relativeSpeedPosterior.drawVector(0, relativeSpeedPosterior.arraySize);
 	
-	ofSetColor(0,0,255);
-	tmpPosteriorForStorage.drawVector(0, tmpPosteriorForStorage.arraySize);
+//	ofSetColor(0,0,255);
+//	tmpPosteriorForStorage.drawVector(0, tmpPosteriorForStorage.arraySize);
 	
 	ofSetColor(255,255, 255);
 	ofLine(screenWidth/2, 0, screenWidth/2, ofGetHeight());//middle of screen
 	
-	ofSetColor(0, 255, 0);
-	double fractionOfScreen = ((double)relativeSpeedPosterior.MAPestimate / relativeSpeedPosterior.length);
+	ofSetColor(155,255, 0);
+	double fractionOfScreen = ((double)relativeSpeedPosterior.integratedEstimate / relativeSpeedPosterior.length);
 	ofLine(screenWidth * fractionOfScreen, 0, screenWidth * fractionOfScreen, ofGetHeight());
 }
 
 
 void BayesianArrayStructure::drawArraysRelativeToTimeframe(const double& startTimeMillis, const double& endTimeMillis){

 		
 		
 	}
 
 }
+
+
+/*
+ 
+ void BayesianArrayStructure::updateTempoDistribution(const double& speedRatio, const double& matchFactor){
+ //speedratio is speed of played relative to the recording
+ 
+ double index = relativeSpeedLikelihood.getRealTermsAsIndex(speedRatio);
+ //	printf("\nindex of likelihood would be %f\n", index);
+ if (index >= 0 && index < relativeSpeedPrior.length){
+ //then we can do update
+ 
+ //set new likelihood
+ relativeSpeedLikelihood.zero();
+ relativeSpeedLikelihood.addConstant(speedLikelihoodNoise);
+ 
+ relativeSpeedLikelihood.addGaussianShape(index , 5, 0.5*matchFactor);
+ 
+ 
+ //copy posterior to prior
+ relativeSpeedPrior.copyFromDynamicVector(relativeSpeedPosterior);
+ 
+ //update
+ relativeSpeedPosterior.doProduct(relativeSpeedPrior, relativeSpeedLikelihood);
+ 
+ //normalise
+ relativeSpeedPosterior.renormalise();
+ 
+ relativeSpeedPosterior.getMaximum();	
+ }//end if within range
+ 
+ 
+ }
+ 
+ */