comparison src/BayesianArrayStructure.cpp @ 2:5581023e0de4

Added separate CannamMidiFileLoader class to handle the loading in.

 	
 	prior.createVector(1);
 	likelihood.createVector(1);
 	posterior.createVector(1);
 
-	
-	tmpPrior.createVector(240);
-	tmpPrior.addGaussianShape(100, 40, 1);
-	tmpPrior.addGaussianShape(200, 10, 0.2);
-	tmpPrior.translateDistribution(20);
-	
+
 	lastEventTime = ofGetElapsedTimeMillis();
 	
-	speedDecayWidth = 20;
-	speedDecayAmount = 10;
+	/*
+	 tmpPrior.createVector(240);
+	 tmpPrior.addGaussianShape(100, 40, 1);
+	 tmpPrior.addGaussianShape(200, 10, 0.2);
+	 tmpPrior.translateDistribution(20);
+	 */
+	tmpBestEstimate = 0;
 }
 
 BayesianArrayStructure::BayesianArrayStructure(int length){
 	printf("BAYESIAN STURTUCRE CREATED LENGTH: %i\n", length);
 	//this constructor isnt called  it seems
 	prior.createVector(length);
 	likelihood.createVector(length);
 	posterior.createVector(length);
+	
+	lastEventTime = 0;
 
 }
 
 
 

 	printf("BAYESIAN STRUCTURE size is : %i\n", length);
 	
 	prior.createVector(length);
 	likelihood.createVector(length);
 	posterior.createVector(length);
+	
 	
 	acceleration.createVector(length);
 	
 }
 

 void BayesianArrayStructure::resetSpeedToOne(){
 	relativeSpeedPrior.zero();
 	relativeSpeedPosterior.zero();
 	relativeSpeedLikelihood.zero();
 	
-	relativeSpeedPosterior.addGaussianShape(40, 5, 0.6);
-	
-	relativeSpeedPosterior.addGaussianShape(100, 5, 0.8);
+	//relativeSpeedPosterior.addGaussianShape(40, 5, 0.6);
+	
+	relativeSpeedPosterior.addGaussianShape(100, 20, 0.8);
+//	relativeSpeedPosterior.addGaussianShape(50, 1, 0.8);
+	
+//	relativeSpeedPosterior.addToIndex(100, 1);
+	//relativeSpeedPosterior.addToIndex(50, 1);
 	relativeSpeedPosterior.renormalise();
 	relativeSpeedPosterior.getMaximum();
 	
-	acceleration.addGaussianShape(2000, 20, 0.8);
+	prior.zero();
+	posterior.zero();
+//	posterior.offset = - 200;
+//	posterior.addGaussianShape(200, 40, 1);
+	posterior.addToIndex(0, 1);
+	posterior.renormalise();
+	
+	//acceleration.addGaussianShape(2000, 20, 0.8);
 	
 }
 
 void BayesianArrayStructure::resetSpeedSize(int length){
 	printf("BAYESIAN SPEED size is : %i\n", length);
 	
 	relativeSpeedPrior.createVector(length);
 	relativeSpeedLikelihood.createVector(length);
 	relativeSpeedPosterior.createVector(length);
-	
-	
-
-}
+	tmpPosteriorForStorage.createVector(length);
+	
+
+}
+
 void BayesianArrayStructure::setRelativeSpeedScalar(double f){
 	relativeSpeedPrior.scalar = f;
 	relativeSpeedPosterior.scalar = f;
 	relativeSpeedLikelihood.scalar = f;
 }
 
+
+void BayesianArrayStructure::setPositionDistributionScalar(double f){
+	if (f > 0){
+	prior.scalar = f;
+	posterior.scalar = f;
+	likelihood.scalar = f;
+	}
+}
+
 void BayesianArrayStructure::simpleExample(){
 	//simple example
-	prior.addGaussianShape(50, 10, 1);
-	prior.addGaussianShape(150, 30, 0.3);
-	prior.addGaussianShape(250, 30, 0.2);
-	
-	likelihood.addGaussianShape(90, 20, 0.6);
-	likelihood.addConstant(0.02);
-	posterior.doProduct(prior, likelihood);
+	
+//	 prior.addGaussianShape(50, 10, 1);
+//	prior.addGaussianShape(150, 30, 0.3);
+//	prior.addGaussianShape(250, 30, 0.2);
+	
+//	likelihood.addGaussianShape(90, 20, 0.6);
+//	likelihood.addConstant(0.02);
+//	posterior.doProduct(prior, likelihood);
 	
 //	relativeSpeedPosterior.addToIndex(100, 1);
 //	relativeSpeedPosterior.addToIndex(40, 0.7);	
-	relativeSpeedPosterior.addGaussianShape(100, 20, 1);
-//	relativeSpeedPosterior.addGaussianShape(10, 2, 0.5);
+	
+//	relativeSpeedPosterior.addGaussianShape(100, 2, 1);
+//	relativeSpeedPosterior.addGaussianShape(40, 2, 0.5);
 	relativeSpeedPosterior.getMaximum();
-	
+	relativeSpeedPrior.copyFromDynamicVector(relativeSpeedPosterior);
 }
 
 void BayesianArrayStructure::copyPriorToPosterior(){
 
 	for (int i = 0;i < prior.arraySize;i++){
 		posterior.array[i] = prior.array[i];
 	}
 }
 
+void BayesianArrayStructure::setStartPlaying(){
+	lastEventTime = 0;//ofGetElapsedTimeMillis();
+	bestEstimate = 0;
+	lastBestEstimateUpdateTime = ofGetElapsedTimeMillis();
+	
+	resetArrays();
+}
+
 void BayesianArrayStructure::resetArrays(){
+	//called when we start playing
+	
 	prior.zero();
 	likelihood.zero();
-	prior.addGaussianShape(0, 80, 1);
+	posterior.zero();
+	
+	updateCounter = 0;
+	
+	posterior.offset = 0;
+	setNewDistributionOffsets(0);
+	
+	int zeroIndex = posterior.getRealTermsAsIndex(0);
+	
+	posterior.addGaussianShape(zeroIndex, 500, 1);
+	//	posterior.addToIndex(0, 1);
 	likelihood.addConstant(1);
-	posterior.zero();
-	posterior.addGaussianShape(0, 60, 1);
-	setNewDistributionOffsets(0);
+	
+	updateCounter = 0;
+	
 	bestEstimate = 0;
 //	lastBestEstimateUpdateTime = ofGetElapsedTimeMillis();
 	
 }
 
+void BayesianArrayStructure::zeroArrays(){
+	prior.zero();
+	likelihood.zero();
+	posterior.zero();
+	
+	relativeSpeedPrior.zero();
+	relativeSpeedPosterior.zero();
+	relativeSpeedLikelihood.zero();
+
+}
+
+
+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);
+	// 
+	printf("tmp best %f and best %f time diff %f posterior MAP %f\n", tmpBestEstimate, bestEstimate, timeDifference, posterior.getIndexInRealTerms(posterior.MAPestimate));
+	//lastBestEstimateUpdateTime = ofGetElapsedTimeMillis();
+}
+	
 void BayesianArrayStructure::updateBestEstimate(){
-	double timeDiff = ofGetElapsedTimeMillis() - lastEventTime;//lastBestEstimateUpdateTime;
-	
+//	double timeDiff = ofGetElapsedTimeMillis() - lastEventTime;//
+	double timeDiff = ofGetElapsedTimeMillis() - lastBestEstimateUpdateTime;
 	bestEstimate = posterior.getIndexInRealTerms(posterior.MAPestimate) + timeDiff*relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);
-	// 
-	//lastBestEstimateUpdateTime = ofGetElapsedTimeMillis();
+	
+//	bestEstimate = tmpBestEstimate;
 }
 
 void BayesianArrayStructure::calculatePosterior(){
-	posterior.doProduct(prior, likelihood);
+	//posterior.doProduct(prior, likelihood);
+	
+	int i;
+	for (i = 0;i < posterior.length;i++){
+		posterior.array[i] = likelihood.array[i] * prior.array[i];
+	}
+	
+	
 	posterior.renormalise();
 	
-	/*
-	int i;
-	for (i = 0;i < prior.length;i++){
-	//	printf("priori [%i] is %f\n", i, prior[i]);
-		*(posterior+i) = *(prior+i);
-	//	posterior[i] = likelihood[i] * prior[i];
-	}
-	 */
+
 
 	 
 }
 
 
 
 
 void BayesianArrayStructure::setNewDistributionOffsets(const double& newOffset){
 	prior.offset = newOffset;
 	likelihood.offset = newOffset;
-//	posterior.offset = newOffset;
+	//posterior.offset = newOffset;
 }
 
 
 void BayesianArrayStructure::crossUpdateArrays(DynamicVector& position, DynamicVector& speed, double timeDifference){
 	//set the cutoff for offset of position first! XXX

 		//so we have moved 
 		int distanceMoved = round(timeDifferenceInPositionVectorUnits * speedValue);//round the value
 		
 		if (speed.array[i] != 0){
 			
-		//	printf("speed [%i] gives %f moved %i\n", i, speedValue, distanceMoved);
+		//	printf("speed [%i] gives %f moved %i in %f units \n", i, speedValue, distanceMoved, timeDifferenceInPositionVectorUnits);
 			
 		for (int postIndex = 0;postIndex < position.arraySize;postIndex++){
-		//old posterior contributing to new prior
+			//old posterior contributing to new prior
 			int newPriorIndex = postIndex + position.offset - prior.offset + distanceMoved;
 			if (newPriorIndex >= 0 && newPriorIndex < prior.arraySize){
 				prior.addToIndex(newPriorIndex, position.array[postIndex]*speed.array[i]);
 			//	printf("adding [%i] : %f\n", newPriorIndex, posterior.array[postIndex]*speed.array[i]);
 			}
 		
 		}
 			
 		}//if not zero
 	}//end speed
-
+	updateCounter++;
 	prior.renormalise();
 
+}
+
+
+void BayesianArrayStructure::addGaussianNoiseToSpeedPosterior(const double& std_dev){
+	tmpPosteriorForStorage.copyFromDynamicVector(relativeSpeedPosterior);
+	
+	for (int i = 0;i < relativeSpeedPosterior.length;i++){
+		tmpPosteriorForStorage.addGaussianShape(i, std_dev, relativeSpeedPosterior.array[i]);
+		}
+												
+	tmpPosteriorForStorage.renormalise();
+	
+	relativeSpeedPosterior.copyFromDynamicVector(tmpPosteriorForStorage);											
+}
+
+
+void BayesianArrayStructure::addTriangularNoiseToSpeedPosterior(const double& std_dev){
+	tmpPosteriorForStorage.copyFromDynamicVector(relativeSpeedPosterior);
+	
+	for (int i = 0;i < relativeSpeedPosterior.length;i++){
+		//adding a linear amount depending on distance
+		tmpPosteriorForStorage.addTriangularShape(i, std_dev*2.0, relativeSpeedPosterior.array[i]);
+	}
+	
+	tmpPosteriorForStorage.renormalise();
+	
+	relativeSpeedPosterior.copyFromDynamicVector(tmpPosteriorForStorage);											
 }
 
 void BayesianArrayStructure::calculateNewPriorOffset(const double& timeDifference){
 	
 	double maxSpeed = relativeSpeedPosterior.getIndexInRealTerms(relativeSpeedPosterior.MAPestimate);

 	if (index >= 0 && index < relativeSpeedPrior.length){
 		//then we can do update
 		
 		//set new likelihood
 		relativeSpeedLikelihood.zero();
-		relativeSpeedLikelihood.addConstant(0.05);
+		relativeSpeedLikelihood.addConstant(speedLikelihoodNoise);
 		
 	relativeSpeedLikelihood.addGaussianShape(index , 5, 0.5*matchFactor);
 	
 
 	//copy posterior to prior

 	
 	//bayesArray.drawFloatArray(&bayesArray.prior[0], 0, 200);
 	//bayesArray.drawFloatArray(&bayesArray.prior[0], 0, 200);
 	
 	int displaySize = prior.arraySize;
-	ofSetColor(255,0,0);
+	ofSetColor(0,0,255);
 	prior.drawVector(0, displaySize);
 	ofSetColor(0,255,0);
 	likelihood.drawVector(0, displaySize);
-	ofSetColor(0,0,255);
+	ofSetColor(255,0,255);
 	posterior.drawVector(0, displaySize);
-	ofSetColor(255,255,0);
-	relativeSpeedPosterior.drawVector(0, relativeSpeedPosterior.arraySize);
+	
 	
 //	ofSetColor(255,255,255);
 //	tmpPrior.drawVector(0,300);
 	
 }

 	ofSetColor(255,0,255);
 	relativeSpeedLikelihood.drawVector(0, relativeSpeedLikelihood.arraySize);
 	
 	ofSetColor(255,255,0);
 	relativeSpeedPosterior.drawVector(0, relativeSpeedPosterior.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);