andrew@4: /*
andrew@4:  *  TimeWarp.cpp
andrew@4:  *  chromaReader13
andrew@4:  *
andrew@4:  *  Created by Andrew on 16/05/2011.
andrew@4:  *  Copyright 2011 QMUL. All rights reserved.
andrew@4:  *
andrew@4:  */
andrew@4: 
andrew@4: #include "TimeWarp.h"
andrew@4: 
andrew@4: #include "stdio.h"
andrew@4: #include "aubio.h"
andrew@4: #include <iostream>
andrew@4: #include <cstring>
andrew@4: #include <string>
andrew@4: #include <cstdlib> 
andrew@4: 
andrew@4: //FIX CHORDS IN THE NEW POINTER VERSION OF THE PROCESS AUDIO FN
andrew@4: 
andrew@4: //BUG IN WHETHER SECOND SONG LOADED OR NOT
andrew@4: 
andrew@4: 
andrew@4: //CHECK THAT DTW will not call beyond the limits of the two chroma if different sizes
andrew@4: 
andrew@4: //CALC DTW on different sizes
andrew@4: 
andrew@4: //CHECK CORRECT BEST ALIGNMENT METHOD FOR DTW
andrew@4: 
andrew@4: //RE-DO DRAW SO THAT IT DOES NOT CALCULATE EVERY POINT BUT DOES IN SQUARE CHUNKS	
andrew@4: 
andrew@4: //UPDATE START FRAME SO ALIGNMENT IS ALWAYS ON SCREEN
andrew@4: //--------------------------------------------------------------
andrew@4: // destructor
andrew@4: TimeWarp :: TimeWarp(){
andrew@14: 	//diagonalPenalty = 1;//favours diagonal over other paths 
andrew@14: 	//diagonalPenalty = 2;//penalises diagonal so all path gradients equal weighting
andrew@8: 	
andrew@16: 	useDotProduct = false;////true - dot, falseo: Euclidean dist
andrew@4: }	
andrew@4: 
andrew@4: // destructor
andrew@4: TimeWarp :: ~TimeWarp(){
andrew@4: 	
andrew@4: 	chromaMatrix.clear();
andrew@4: 	secondMatrix.clear();
andrew@4: 	firstEnergyVector.clear();
andrew@4: 	secondEnergyVector.clear();	
andrew@4: 	similarityMatrix.clear();
andrew@4: 	alignmentMeasureMatrix.clear();
andrew@5: 	conversionFactor = 16;
andrew@4: 	//matrixPtr.clear();
andrew@4: 	//chromoGramm.~ChromoGram();
andrew@4: 	//secondChromoGramm;
andrew@10: 	anchorPoints.clear();
andrew@4: 	
andrew@4: 	
andrew@4: }	
andrew@8: 
andrew@8: 
andrew@8: void TimeWarp::clearVectors(){
andrew@8: 	firstEnergyVector.clear();
andrew@8: 	secondEnergyVector.clear();
andrew@8: 	chromaMatrix.clear();
andrew@8: 	secondMatrix.clear();
andrew@8: 	similarityMatrix.clear();
andrew@8: 	chromaSimilarityMatrix.clear();
andrew@8: 	tmpSimilarityMatrix.clear();
andrew@8: 	alignmentMeasureMatrix.clear();
andrew@8: 	tmpAlignmentMeasureMatrix.clear();	
andrew@8: 	minimumAlignmentPath.clear();
andrew@8: 	partBackwardsAlignmentPath.clear();
andrew@14: 	forwardsAlignmentPath.clear();
andrew@14: 	anchorPoints.clear();
andrew@8: }
andrew@4: 	
andrew@4: void TimeWarp::initialiseVariables(){
andrew@14: 	similarityMatrix.clear();
andrew@14: 	chromaSimilarityMatrix.clear();
andrew@14: 	tmpSimilarityMatrix.clear();
andrew@14: 	alignmentMeasureMatrix.clear();
andrew@14: 	tmpAlignmentMeasureMatrix.clear();	
andrew@14: 	minimumAlignmentPath.clear();
andrew@14: 	partBackwardsAlignmentPath.clear();
andrew@14: 	forwardsAlignmentPath.clear();
andrew@14: 	anchorPoints.clear();
andrew@14: 	
andrew@14: 	//diagonalPenalty = 1;
andrew@4: 	//chromoGramm.initialise(FRAMESIZE,2048);//framesize 512 and hopsize 2048
andrew@4: 
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: void TimeWarp::createCombinedMatrix(DoubleMatrix myChromaMatrix, DoubleVector energyVector, DoubleMatrix* chromaEnergyMatrix){
andrew@4: 	chromaEnergyMatrix->clear();
andrew@4: 	int sizeRatio = energyVector.size() / myChromaMatrix.size();//
andrew@4: 	printf("COMBINE: size of my chroma is %i\n", (int) myChromaMatrix.size());// energyVector.size() / myChromaMatrix.size();
andrew@4: 	printf("COMBINED: size ratio of energy to chroma is %i \n", sizeRatio);
andrew@4: 	int chromaSize = myChromaMatrix.size();	
andrew@4: //	printf("index is %i\n", index);
andrew@4: 	
andrew@4: 	for (int i = 0;i < energyVector.size();i++){
andrew@4: 		DoubleVector d;
andrew@4: 		int index = min(chromaSize-1, (int) floor(i/sizeRatio));
andrew@4: 
andrew@4: 		for (int y = 0;y < 12;y++){
andrew@4: 			d.push_back(myChromaMatrix[index][y]);//
andrew@4: 		}
andrew@4: 
andrew@4: 		
andrew@4: 		d.push_back(energyVector[i]);
andrew@4: 					(*chromaEnergyMatrix).push_back(d);
andrew@4: 	}
andrew@4: 	printf("COMBINED: size of chroma energy is %i\n", (int)(*chromaEnergyMatrix).size());
andrew@4: 
andrew@5: //	int x = (int)(*chromaEnergyMatrix).size()/3;
andrew@4: //	printf("energy[%i] %f \n", x, energyVector[x]);
andrew@4: /*
andrew@4:  for (int y = 0;y < 13;y++){
andrew@4: 		printf("chroma[%i][%i] %f \n", x, y, myChromaMatrix[x/sizeRatio][y]);
andrew@4: 		printf("c[%i][%i] %f \n", x, y, (*chromaEnergyMatrix)[x][y]);
andrew@4: 	}
andrew@4: 		printf("\n");
andrew@4: */	
andrew@4: 
andrew@4: }
andrew@4: 
andrew@4: void TimeWarp::calculateSimilarityMatrix(){
andrew@5: 	calculateSimilarityMatrixWithPointers(&chromaMatrix, &secondMatrix, &similarityMatrix);
andrew@4: 									  
andrew@4: 		/*								  
andrew@4: 	similarityMatrix.clear();
andrew@4: 	printf("calculating similarity matrix...")
andrew@4: 	//	userInfoString = "calculating similarity matrix...";
andrew@4: 	
andrew@4: 	double distance, firstSum, secondSum;
andrew@4: 	
andrew@4: 	for (int x = 0;x < chromaMatrix.size();x++){
andrew@4: 		DoubleVector d;
andrew@4: 		
andrew@4: 		
andrew@4: 		 for (int y = 0;y < secondMatrix.size();y++){
andrew@4: 			
andrew@4: 			distance = 0;
andrew@4: 			firstSum = 0;
andrew@4: 			secondSum = 0;
andrew@4: 			
andrew@4: 			for (int z = 0;z < chromaMatrix[x].size();z++){//z is the twelve chromagram values
andrew@4: 				
andrew@4: 				distance += chromaMatrix[x][z] * secondMatrix[y][z];
andrew@4: 				
andrew@4: 				firstSum += chromaMatrix[x][z] * chromaMatrix[x][z];
andrew@4: 				secondSum += secondMatrix[y][z] * secondMatrix[y][z];
andrew@4: 			}
andrew@4: 			
andrew@4: 			if (firstSum > 0 && secondSum > 0)
andrew@4: 				distance /= sqrt(firstSum * secondSum);
andrew@4: 			
andrew@4: 			
andrew@4: 			d.push_back( distance);	
andrew@4: 			
andrew@4: 		}	//end for y
andrew@4: 		
andrew@4: 		similarityMatrix.push_back(d);
andrew@4: 		
andrew@4: 	}//end for x
andrew@4: 	*/
andrew@4: //	printf("..sim size: %i, height: %i \n", (int) similarityMatrix.size(), (int) (chromaMatrix[0]).size());
andrew@4: 	
andrew@4: }//end self sim
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@5: void TimeWarp::calculateSimilarityMatrixWithPointers(DoubleMatrix* firstChromaMatrix, DoubleMatrix* secondChromaMatrix, DoubleMatrix* simMatrix){
andrew@5: 	printf("Calculate similarity : pointers : size %i x %i  ", (int) (*firstChromaMatrix).size(), (int) (*secondChromaMatrix).size());
andrew@4: 	
andrew@8: 	simMatrix->clear();
andrew@4: 
andrew@4: 	double distance, firstSum, secondSum;
andrew@4: 	
andrew@5: 	for (int x = 0;x < (*firstChromaMatrix).size();x++){
andrew@4: 		DoubleVector d;
andrew@4: 		
andrew@5: 		for (int y = 0;y < (*secondChromaMatrix).size();y++){
andrew@4: 			
andrew@15: 			if (useDotProduct)
andrew@15: 				distance = getChromaSimilarity(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@15: 			else
andrew@15: 				distance = getEuclideanDistance(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@4: 			
andrew@4: 			d.push_back( distance);	
andrew@4: 		}	//end for y
andrew@4: 		
andrew@4: 		(*simMatrix).push_back(d);
andrew@4: 		
andrew@4: 	}//end for x
andrew@4: 
andrew@4: 		 printf("..sim size: %i, height: %i \n", (int) (*simMatrix).size(), (int) (*simMatrix)[0].size());
andrew@4: 	
andrew@4: }//end self sim
andrew@4: 
andrew@4: 
andrew@5: void TimeWarp::calculateJointSimilarityMatrix(DoubleVector* energyVectorOne, DoubleVector* energyVectorTwo,  DoubleMatrix*  chromaSimilarityMatrix, DoubleMatrix* simMatrix){
andrew@5: 
andrew@5: 	//requires a chromagram similarity first this already done
andrew@5: 	//calculateSimilarityMatrixWithPointers(chromaMatrixOne, chromaMatrixTwo, &chromaSimilarityMatrix);
andrew@5: 	
andrew@5: 	conversionFactor = (int) round((*energyVectorOne).size() / (*chromaSimilarityMatrix).size() );
andrew@5: 	
andrew@12: 	printf("tw.ROUNDED CONVERSION FACTOR IS %i\n", conversionFactor);
andrew@12: 	printf("tw.CHROMA SIM SIZE %i\n", (int) (*chromaSimilarityMatrix).size());
andrew@5: 	
andrew@8: 	simMatrix->clear();
andrew@5: 
andrew@5: 	double energyProportion = 0.3;
andrew@5: 	double chromaProportion = 1 - energyProportion;
andrew@5: 	
andrew@5: 	double distance, firstSum, secondSum;
andrew@5: 	
andrew@12: 	//lets try not actually doing calculation
andrew@12: 	
andrew@5: 	for (int x = 0;x < (*energyVectorOne).size();x++){
andrew@5: 		DoubleVector d;
andrew@5: 		
andrew@5: 		for (int y = 0;y < (*energyVectorTwo).size();y++){
andrew@5: 			
andrew@5: 			//create chroma similarity first
andrew@5: 			
andrew@5: 			//			distance = (*energyVectorOne)[x] * (*energyVectorTwo)[y];//energy similarity
andrew@5: 			
andrew@5: 			//now need the chroma part
andrew@5: 			int chromaIndexX = min(x / conversionFactor, (int)(*chromaSimilarityMatrix).size()-1);
andrew@5: 			int chromaIndexY = min(y / conversionFactor, (int)(*chromaSimilarityMatrix)[chromaIndexX].size()-1);
andrew@5: 			
andrew@5: 			double chromaComponent = (*chromaSimilarityMatrix)[chromaIndexX][chromaIndexY];
andrew@5: //			getChromaSimilarity(chromaIndexX, chromaIndexY, firstChromaMatrix, secondChromaMatrix);
andrew@5: 				
andrew@5: 
andrew@5: 			distance *= energyProportion;
andrew@5: 			distance += chromaProportion * chromaComponent;
andrew@5: 						
andrew@5: 			//distance = getJointChromaAndEnergyDistance(energyVectorOne, firstChromaMatrix, energyVectorTwo, secondChromaMatrix, x, y, conversionFactor, energyProportion, chromaProportion);
andrew@5: 			
andrew@5: 
andrew@5: 			
andrew@5: 			d.push_back( distance);	
andrew@5: 		}	//end for y
andrew@5: 		
andrew@5: 		(*simMatrix).push_back(d);
andrew@5: 		
andrew@5: 	}//end for x
andrew@12: 	 
andrew@12: 	 printf("..sim size: %i, height: %i \n", (int) (*simMatrix).size(), (int) (*simMatrix)[0].size());
andrew@12: 	 
andrew@12: 
andrew@5: 	
andrew@5: }
andrew@5: 
andrew@5: double TimeWarp::getJointChromaAndEnergyDistance(DoubleVector* energyVectorOne, DoubleMatrix* firstChromaMatrix, DoubleVector* energyVectorTwo, DoubleMatrix* secondChromaMatrix, int energyIndexX, int energyIndexY, double energyProportion, double chromaProportion){
andrew@5: 	//create chroma similarity first
andrew@5: 	double distance = 0;
andrew@5: 	
andrew@5: 	if (energyIndexX >= 0 && energyIndexY >= 0 && energyIndexX < (*energyVectorOne).size() && energyIndexY < (*energyVectorTwo).size()){
andrew@5: 	
andrew@5: 	distance = (*energyVectorOne)[energyIndexX] * (*energyVectorTwo)[energyIndexY];//energy similarity
andrew@5: 	
andrew@5: 	//now need the chroma part
andrew@5: 	int chromaIndexX = min(energyIndexX / conversionFactor, (int)(*firstChromaMatrix).size()-1);
andrew@5: 	int chromaIndexY = min(energyIndexY / conversionFactor, (int)(*secondChromaMatrix).size()-1);
andrew@5: 	double chromaComponent = getChromaSimilarity(chromaIndexX, chromaIndexY, firstChromaMatrix, secondChromaMatrix);
andrew@5: 			
andrew@5: 	distance *= energyProportion;
andrew@5: 	distance += chromaProportion * chromaComponent;
andrew@5: 	}
andrew@5: 	return distance;
andrew@5: }
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: void TimeWarp::calculateChromaSimilarityMatrix(DoubleMatrix* firstChromaMatrix, DoubleMatrix* secondChromaMatrix, DoubleMatrix* simMatrix){
andrew@5: //calculates the chroma only similarity matrix - used to reduce computation later when doing the joint energy and chroma matrix
andrew@5: 	for (int x = 0;x < (*firstChromaMatrix).size();x++){
andrew@5: 		DoubleVector d;
andrew@5: 		for (int y = 0;y < (*secondChromaMatrix).size();y++){
andrew@5: 			double distance;
andrew@15: 			if (useDotProduct)
andrew@5: 			distance = getChromaSimilarity(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@15: 			else
andrew@15: 			distance = getEuclideanDistance(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@15: 			
andrew@5: 			d.push_back( distance);	
andrew@5: 		}
andrew@5: 		(*simMatrix).push_back(d);
andrew@5: 	}
andrew@5: 	printf("CHROMA ONLY SIM SIZE %i x %i\n", (int)(*simMatrix).size(), (int)(*simMatrix)[0].size());
andrew@5: 	
andrew@5: }
andrew@5: 
andrew@5: double TimeWarp::getChromaSimilarity(int x, int y, DoubleMatrix* firstChromaMatrix, DoubleMatrix* secondChromaMatrix){
andrew@5: 	
andrew@5: 	double distance = 0;
andrew@5: 	double firstSum = 0;
andrew@5: 	double secondSum = 0;
andrew@5: 	
andrew@5: 	if (x >= 0 && x < (*firstChromaMatrix).size() && y >= 0 && y < (*secondChromaMatrix).size()){
andrew@5: 		for (int z = 0;z < (*firstChromaMatrix)[x].size();z++){//z is the twelve chromagram values
andrew@5: 			
andrew@5: 		distance += (*firstChromaMatrix)[x][z] * (*secondChromaMatrix)[y][z];
andrew@5: 		firstSum += (*firstChromaMatrix)[x][z] * (*firstChromaMatrix)[x][z];
andrew@5: 		secondSum += (*secondChromaMatrix)[y][z] * (*secondChromaMatrix)[y][z];
andrew@5: 		}
andrew@5: 		
andrew@5: 		if (firstSum > 0 && secondSum > 0)
andrew@5: 			distance /= sqrt(firstSum)*sqrt(secondSum);
andrew@5: 	}
andrew@5: 	
andrew@5: 	return distance;
andrew@5: 	
andrew@5: }
andrew@5: 
andrew@5: 
andrew@15: double TimeWarp::getEuclideanDistance(int x, int y, DoubleMatrix* firstChromaMatrix, DoubleMatrix* secondChromaMatrix){
andrew@15: 
andrew@15: 	double distance = 0;
andrew@15: 	double newDistance = 0;
andrew@15: 	
andrew@15: 	if (x >= 0 && x < (*firstChromaMatrix).size() && y >= 0 && y < (*secondChromaMatrix).size()){
andrew@15: 		for (int z = 0;z < (*firstChromaMatrix)[x].size();z++){//z is the twelve chromagram values
andrew@15: 			newDistance = (*firstChromaMatrix)[x][z] - (*secondChromaMatrix)[y][z];
andrew@15: 			distance += newDistance*newDistance;
andrew@15: 		}
andrew@15: 	}
andrew@15: 	
andrew@15: 	return 1-sqrt(distance);
andrew@15: 	
andrew@15: }
andrew@15: 
andrew@15: 
andrew@10: void TimeWarp::addAnchorPoints(const int&  startFrameX, const int& startFrameY){
andrew@10: 	IntVector v;
andrew@10: 	v.push_back(startFrameX);
andrew@10: 	v.push_back(startFrameY);
andrew@10: 	anchorPoints.push_back(v);
andrew@10: }
andrew@5: 
andrew@4: void TimeWarp::calculateAlignmentMatrix(DoubleMatrix firstMatrix, DoubleMatrix secondMatrix, DoubleMatrix* alignmentMatrix){//, DoubleMatrix simMatrix
andrew@4: 	printf("starting Alignment calculation\n");
andrew@4: 	//initialise alignment
andrew@8: 	alignmentMatrix->clear();
andrew@8: 
andrew@4: 	DoubleVector d;
andrew@4: 	d.push_back(getDistance(0,0));
andrew@4: 	(*alignmentMatrix).push_back(d);
andrew@4: 	
andrew@4: 	bool chromaCalculated = false;
andrew@4: 	bool secondCalculated = false;
andrew@4: 	
andrew@4: 	while (!chromaCalculated || !secondCalculated) {
andrew@4: 		
andrew@4: 		if (!chromaCalculated)
andrew@4: 			chromaCalculated = extendAlignmentAlong((int) firstMatrix.size(), alignmentMatrix);
andrew@4: 		
andrew@4: 		if (!secondCalculated)
andrew@4: 			secondCalculated = extendAlignmentUp((int) secondMatrix.size(), alignmentMatrix);
andrew@4: 		
andrew@4: 	}
andrew@4: 	printf("Alignment matrix calculated, size %i\n", (int) (*alignmentMatrix).size());
andrew@4: }
andrew@4: 
andrew@4: bool TimeWarp::extendAlignmentUp(int endIndexY, DoubleMatrix *alignmentMatrix){
andrew@4: 	DoubleVector d;
andrew@4: 	d = (*alignmentMatrix)[0];//alignmentMatrix[0];//
andrew@4: 	int heightSize = d.size();
andrew@4: 	if (heightSize < endIndexY){
andrew@4: 		//then we haven't finished yet
andrew@4: 		for (int i = 0;i < (*alignmentMatrix).size();i++){
andrew@4: 			double value = getDistance(i, heightSize);
andrew@4: 			value += getRestrictedMinimum(i, heightSize, value, 0, 0);//min values 0	
andrew@4: 			(*alignmentMatrix)[i].push_back(value);//
andrew@4: 		}
andrew@4: 	}
andrew@4: 	if ((*alignmentMatrix)[0].size() == endIndexY)
andrew@4: 		return true;
andrew@4: 	else
andrew@4: 		return false;
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: bool TimeWarp::extendAlignmentAlong(int endIndexX, DoubleMatrix* alignmentMatrix){
andrew@4: 	DoubleVector d;
andrew@4: 	//firstMatrix.size()
andrew@4: 	int widthSize = (*alignmentMatrix).size();
andrew@4: 	if (widthSize < endIndexX){//firstMatrix.size()
andrew@4: 		//then we can extend along
andrew@4: 		double value = getDistance(widthSize, 0);
andrew@4: 		value += getRestrictedMinimum(widthSize, 0, value, 0, 0);
andrew@4: 		
andrew@4: 		d.push_back(value);
andrew@4: 		(*alignmentMatrix).push_back(d);
andrew@4: 		
andrew@4: 		for (int j = 1;j < (*alignmentMatrix)[widthSize - 1].size();j++){
andrew@4: 			value = getDistance(widthSize, j);
andrew@4: 			value += getMinimum(widthSize, j, value);
andrew@4: 			(*alignmentMatrix)[widthSize].push_back(value);
andrew@4: 		}
andrew@4: 		
andrew@4: 	}
andrew@4: 	
andrew@4: 	if ((*alignmentMatrix).size() == endIndexX)
andrew@4: 		return true;
andrew@4: 	else
andrew@4: 		return false;
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: 
andrew@5: void TimeWarp::calculatePartSimilarityMatrix(DoubleMatrix* firstChromaMatrix, DoubleMatrix* secondChromaMatrix, DoubleMatrix* simMatrix, int startX, int startY, int endX){
andrew@4: //	printf("Calculate similarity : pointers : size %i x %i  ", (int) firstChromaMatrix.size(), (int) secondChromaMatrix.size());
andrew@4: 	
andrew@8: 	simMatrix->clear();
andrew@4: 	
andrew@4: 	double distance, firstSum, secondSum;
andrew@5: 	endX = min (endX, (int)(*firstChromaMatrix).size()-1);//in case out of size
andrew@4: 	
andrew@4: 	for (int x = startX;x <= endX;x++){
andrew@4: 		DoubleVector d;
andrew@4: 		
andrew@5: 		for (int y = startY;y < (*secondChromaMatrix).size();y++){
andrew@15: 
andrew@15: 			if (useDotProduct)
andrew@15: 				distance  = getChromaSimilarity(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@15: 			else
andrew@15: 				distance = getEuclideanDistance(x, y, firstChromaMatrix, secondChromaMatrix);
andrew@4: 			
andrew@4: 			d.push_back( distance);	
andrew@4: 		}	//end for y
andrew@4: 		
andrew@4: 		(*simMatrix).push_back(d);
andrew@4: 		
andrew@4: 	}//end for x
andrew@4: 	
andrew@4: 	printf("..part sim size: %i, height: %i \n", (int) (*simMatrix).size(), (int) (*simMatrix)[0].size());
andrew@4: 	
andrew@4: }//end self sim
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@9: void TimeWarp::calculatePartJointSimilarityMatrix(DoubleVector* firstEnergyVector, DoubleVector* secondEnergyVector, DoubleMatrix* chromaSimMatrix, DoubleMatrix* simMatrix, int startX, int startY, int endX, int endY){
andrew@5: 	printf("PART SIM CALC Calculate similarity : pointers : size %i x %i  ", startX, startY);//(int) (*firstEnergyVector).size(), (int) (*secondEnergyVector).size());
andrew@5: 	
andrew@5: 	conversionFactor = (int) round((*firstEnergyVector).size() / (*chromaSimMatrix).size() );
andrew@8: 	simMatrix->clear();
andrew@5: 	
andrew@14: 	double energyProportion = 0.2;
andrew@5: 	double chromaProportion = 1 - energyProportion;
andrew@5: 	double distance, firstSum, secondSum;
andrew@5: 	
andrew@5: 	endX = min (endX, (int)(*firstEnergyVector).size()-1);//in case out of size
andrew@14: 	endY = min( endY+1, (int)(*secondEnergyVector).size());
andrew@14: 	int lastChromaYvalue = 0;
andrew@14: 	int chromaIndexY = 0;
andrew@14: 	double chromaComponent = 0;
andrew@14: 	double 	chromaContribution = 0;
andrew@14: 		DoubleVector d;	
andrew@5: 	for (int x = startX;x <= endX;x++){
andrew@14: 		d.clear();
andrew@5: 		
andrew@14: 		//now need the chroma part
andrew@14: 		int chromaIndexX = min(x / conversionFactor, (int)(*chromaSimMatrix).size()-1);
andrew@14: 		
andrew@14: 		for (int y = startY;y < endY;y++){
andrew@15: 			chromaIndexY = min(y / conversionFactor, (int)(*chromaSimMatrix)[chromaIndexX].size()-1);
andrew@15: 			
andrew@9: 			//was thinking to restrict the y part too, but not working yet
andrew@15: 			if (chromaIndexY != lastChromaYvalue){			
andrew@15: 			
andrew@14: 			chromaComponent = (*chromaSimMatrix)[chromaIndexX][chromaIndexY];
andrew@15: 				lastChromaYvalue = chromaIndexY;
andrew@15: 				chromaContribution  = chromaProportion * chromaComponent;
andrew@14: 			}
andrew@5: 			
andrew@5: 			distance = (*firstEnergyVector)[x] * (*secondEnergyVector)[y];//energy similarity
andrew@14: 			distance *= energyProportion;
andrew@14: 			distance += chromaContribution;
andrew@5: 			
andrew@15: 			distance = chromaComponent;
andrew@5: 			
andrew@5: 			d.push_back( distance);	
andrew@5: 		}	//end for y
andrew@5: 		
andrew@5: 		(*simMatrix).push_back(d);
andrew@5: 		
andrew@5: 	}//end for x
andrew@5: 	
andrew@5: 	
andrew@5: 	printf("..part JOINT sim size: %i, height: %i \n", (int) (*simMatrix).size(), (int) (*simMatrix)[0].size());
andrew@5: 	
andrew@5: }//end self sim
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: void TimeWarp::calculatePartAlignmentMatrix(int endIndexX, int endIndexY, DoubleMatrix* alignmentMatrix, DoubleMatrix* simMatrix){
andrew@5: 	printf("starting PART Alignment calculation : sim matrix size %i %i\n", (int)(*simMatrix).size(), (int)(*simMatrix)[0].size());
andrew@4: 	//initialise alignment
andrew@8: 	alignmentMatrix->clear();
andrew@8: 	
andrew@4: 	DoubleVector d;
andrew@5: 	d.push_back(getDistanceFromMatrix(0,0, simMatrix));
andrew@5: 		printf("first distance\n");
andrew@4: 	(*alignmentMatrix).push_back(d);
andrew@4: 	
andrew@4: 	bool chromaCalculated = false;
andrew@4: 	bool secondCalculated = false;
andrew@4: 	
andrew@4: 	while (!chromaCalculated || !secondCalculated) {
andrew@4: 		
andrew@4: 		if (!chromaCalculated)
andrew@5: 			chromaCalculated = extendRestrictedAlignmentAlong(endIndexX, alignmentMatrix, simMatrix);
andrew@4: 		
andrew@4: 		if (!secondCalculated)
andrew@5: 			secondCalculated = extendRestrictedAlignmentUp(endIndexY, alignmentMatrix, simMatrix);
andrew@4: 		
andrew@4: 	}
andrew@5: 	printf("PART Alignment matrix calculated, size %i by %i\n", (int) (*alignmentMatrix).size() , (int) (*alignmentMatrix)[0].size());
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@5: bool TimeWarp::extendRestrictedAlignmentUp(int endIndexY, DoubleMatrix *alignmentMatrix, DoubleMatrix* simMatrix){
andrew@4: 	//adds one more value to all the columns after startX
andrew@5: 	
andrew@4: 	DoubleVector d;
andrew@4: 	d = (*alignmentMatrix)[0];//alignmentMatrix[0];//
andrew@4: 	int heightSize = d.size();
andrew@4: 	if (heightSize < endIndexY){
andrew@5: 		//would change 0 to startX if we varied this
andrew@5: 		for (int i = 0;i < (*alignmentMatrix).size();i++){//was < (*alignmentMatrix).size()
andrew@5: 		//	printf("restruicted up  %i, %i\n", i, heightSize);
andrew@5: 			double value = getDistanceFromMatrix(i, heightSize, simMatrix);
andrew@5: 			value += getMinimumFromMatrix(i, heightSize, value, alignmentMatrix);//min values 0	
andrew@4: 			(*alignmentMatrix)[i].push_back(value);//
andrew@4: 		}
andrew@4: 	}
andrew@4: 	if ((*alignmentMatrix)[0].size() == endIndexY)
andrew@4: 		return true;
andrew@4: 	else
andrew@4: 		return false;
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@5: bool TimeWarp::extendRestrictedAlignmentAlong(int endIndexX, DoubleMatrix* alignmentMatrix, DoubleMatrix* simMatrix){
andrew@4: 	DoubleVector d;
andrew@4: 	//firstMatrix.size()
andrew@4: 	int widthSize = (*alignmentMatrix).size();
andrew@4: 	if (widthSize < endIndexX){//firstMatrix.size()
andrew@5: 	//	printf("restruicted along %i\n", widthSize);
andrew@4: 		//then we can extend along
andrew@5: 		double value = getDistanceFromMatrix(widthSize, 0, simMatrix);
andrew@5: 		value += getMinimumFromMatrix(widthSize, 0, value, alignmentMatrix);
andrew@4: 		
andrew@4: 		d.push_back(value);
andrew@4: 		(*alignmentMatrix).push_back(d);
andrew@4: 		
andrew@4: 		for (int j = 1;j < (*alignmentMatrix)[widthSize - 1].size();j++){
andrew@5: 		//	printf("restruicted along %i %i\n", widthSize, j);
andrew@5: 			value = getDistanceFromMatrix(widthSize, j, simMatrix);
andrew@5: 			value += getMinimumFromMatrix(widthSize, j, value, alignmentMatrix);
andrew@4: 			(*alignmentMatrix)[widthSize].push_back(value);
andrew@4: 		}
andrew@4: 		
andrew@4: 	}
andrew@4: 	
andrew@4: 	if ((*alignmentMatrix).size() == endIndexX)
andrew@4: 		return true;
andrew@4: 	else
andrew@4: 		return false;
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@5: 
andrew@5: void TimeWarp::calculateMinimumAlignmentPath(DoubleMatrix* alignmentMatrix, IntMatrix* backPath, bool pickMinimumFlag){
andrew@4: 	//this requires one pass of the DTW algorithm and then works backwards from (N,M)
andrew@4: 	//to find the optimal path to (0,0), where N and M are the lengths of the two chromoVectors respectively
andrew@4: 	
andrew@5: 	(*backPath).clear();
andrew@4: 	
andrew@5: //	printf("Finding minimum Path %i vs sim size %i\n", (int)chromaMatrix.size(), (int)similarityMatrix.size() );
andrew@5: 	
andrew@5: 	printf("Finding minimum Path of alignment matrix %i vs sim size %i\n", (int)(*alignmentMatrix).size(), (int)(*alignmentMatrix)[0].size() );	
andrew@5: //	printf("compares to sim %ix%i\n", similarityMatrix.size()-1, similarityMatrix[0].size()-1);
andrew@4: 	IntVector v;
andrew@5: //	v.push_back(similarityMatrix.size()-1);//chromaMatrix.size()-1 - old way
andrew@5: 	
andrew@5: 	//here we start at the corner of the alignment matrix
andrew@5: 	//could change to greedy? - i.e. the best / minimum of the last vector
andrew@5: 	v.push_back((*alignmentMatrix).size()-1);
andrew@5: 	(*backPath).push_back(v);
andrew@4: 	v.clear();
andrew@5: 	//v.push_back(similarityMatrix[0].size()-1);//secondMatrix
andrew@5: 	int endIndex = (*alignmentMatrix)[(*alignmentMatrix).size()-1].size()-1;
andrew@5: 	if (pickMinimumFlag){
andrew@5: 		endIndex = getMinimumIndexOfColumnFromMatrix((int)(*alignmentMatrix).size()-1, alignmentMatrix);
andrew@5: 		//i.e. get index of minimum in the last column
andrew@5: 	}
andrew@5: 		v.push_back(endIndex);//and the y size
andrew@5: 	printf("CALUCLATE MINIMUM PUSHED BACK %i\n", endIndex);
andrew@5: 	
andrew@5: 	
andrew@5: 	(*backPath).push_back(v);
andrew@4: 	//so now backwards path[0][0] = size(chroma) and path[1][0] = size(secondMatrix)
andrew@5: printf("backwards path initialised to %i : %i \n", (*backPath)[0][0], (*backPath)[1][0]);
andrew@4: 	
andrew@4: 	
andrew@4: 	int indexOfBackwardsPath = 0;
andrew@5: 	while (!findPreviousMinimumInBackwardsPath(alignmentMatrix, backPath))	{
andrew@4: 		indexOfBackwardsPath++;
andrew@5: //		printf("backwards path index %i:  path: %i : %i \n", indexOfBackwardsPath, backwardsAlignmentPath[0][indexOfBackwardsPath], backwardsAlignmentPath[1][indexOfBackwardsPath]);
andrew@4: 		
andrew@4: 	}
andrew@5: 	printf("final index of backwards path is %i and i is %i \n", (int) (*backPath)[0].size()-1, indexOfBackwardsPath);
andrew@4: 	
andrew@4: 	//	backwardsAlignmentIndex = backwardsAlignmentPath[0].size()-1;//remember that this goes backwards!
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@5: 
andrew@5: bool TimeWarp::findPreviousMinimumInBackwardsPath(DoubleMatrix* alignmentMatrix, IntMatrix* backPath){
andrew@5: 	int chromaPosition, secondPosition;
andrew@5: 	int i,j;
andrew@5: 	i = (*backPath)[0][(*backPath)[0].size()-1];
andrew@5: 	j  = (*backPath)[1][(*backPath)[1].size()-1];
andrew@5: 	//printf("FIND PREVIOUS MINIMUM %i %i \n", i, j);
andrew@5: 	
andrew@5: 	double newMinimum;
andrew@5: 	double *ptr;
andrew@5: 	ptr = &newMinimum;
andrew@5: 	newMinimum = (*alignmentMatrix)[i][j];
andrew@5: 	DoubleVector d;
andrew@5: 	
andrew@5: 	
andrew@5: 	bool finishedAligning = true;
andrew@5: 	
andrew@5: 	if (i > 0){
andrew@5: 		if (testForNewAlignmentMinimum(ptr, i-1, j, alignmentMatrix)){
andrew@5: 			chromaPosition = i-1;
andrew@5: 			secondPosition = j;
andrew@5: 			finishedAligning = false;
andrew@5: 		}
andrew@5: 		
andrew@5: 		if (j>0 && testForNewAlignmentMinimum(ptr, i-1, j-1, alignmentMatrix)){
andrew@5: 			chromaPosition = i-1;
andrew@5: 			secondPosition = j-1;
andrew@5: 			finishedAligning = false;
andrew@5: 		}
andrew@5: 	}
andrew@5: 	
andrew@5: 	if (j > 0 && testForNewAlignmentMinimum(ptr, i, j-1, alignmentMatrix)){
andrew@5: 		chromaPosition = i;
andrew@5: 		secondPosition = j-1;
andrew@5: 		//newMinimum = alignmentMeasureMatrix[chromaPosition][secondPosition];
andrew@5: 		finishedAligning = false;
andrew@5: 	}
andrew@5: 	
andrew@5: 	if (!finishedAligning){
andrew@5: 		(*backPath)[0].push_back(chromaPosition);
andrew@5: 		(*backPath)[1].push_back(secondPosition);
andrew@5: 	}
andrew@5: 	
andrew@5: 	return finishedAligning;
andrew@5: 	
andrew@5: }	
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: bool TimeWarp::testForNewAlignmentMinimum(double *previousMinimum, int i, int j, DoubleMatrix* alignmentMatrix){
andrew@5: 	bool newMinimumFound = false;
andrew@5: 	if ((*alignmentMatrix)[i][j] < *previousMinimum){
andrew@5: 		*previousMinimum = (*alignmentMatrix)[i][j];							   
andrew@5: 		newMinimumFound = true;
andrew@5: 	}
andrew@5: 	
andrew@5: 	return newMinimumFound;							   
andrew@5: }															
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: 
andrew@8: void TimeWarp::printBackwardsPath(int startIndex, int endIndex, const IntMatrix* backPath){
andrew@5: 	if (endIndex <= (*backPath)[0].size()){
andrew@8: 		printf("size of path is %i by %i\n", (int) (*backPath).size(), (int) (*backPath)[0].size());
andrew@5: 	for (int i = startIndex;i < endIndex;i++){
andrew@6: 		printf("Path[%i]:: %i : %i \n", i, (*backPath)[0][i], (*backPath)[1][i]);
andrew@5: 		}
andrew@5: 	}
andrew@5: }
andrew@5: 
andrew@5: 
andrew@5: void TimeWarp::extendForwardAlignmentPath(int endX, IntMatrix* backPath, int anchorPointX, int anchorPointY){
andrew@5: 	//andchor points are the starting index so if we have already done up to 
andrew@4: int forwardsIndex = forwardsAlignmentPath.size();
andrew@5: 	int indexX = (*backPath)[0].size() - 1;
andrew@4: 	
andrew@4: 	if (forwardsIndex == 0){
andrew@4: 		printf("initialise forwards path..\n");
andrew@4: 	IntVector v;
andrew@4: 	
andrew@5: 	v.push_back((*backPath)[0][indexX]);//chromaMatrix.size()-1
andrew@4: 	forwardsAlignmentPath.push_back(v);
andrew@4: 	v.clear();
andrew@4: 	v.push_back(forwardsAlignmentPath[0][indexX]);//secondMatrix
andrew@4: 	forwardsAlignmentPath.push_back(v);
andrew@4: 	indexX--;
andrew@5: 	printf("FORWARDS PATH STARTED AS %i, %i\n", forwardsAlignmentPath[0][0], forwardsAlignmentPath[0][1]);
andrew@5: 	}
andrew@5: 	else{
andrew@5: 	//forwards path has been started and we need anchor point
andrew@5: 		
andrew@4: 	}
andrew@4: 	
andrew@5: 	
andrew@5: 	while ((*backPath)[0][indexX] <= endX){
andrew@5: 		addNewForwardsPath(indexX, backPath, anchorPointX, anchorPointY);
andrew@5: 	//	printf("Forwards path from index %i:: path %i : %i\n", indexX, forwardsAlignmentPath[0][forwardsIndex], forwardsAlignmentPath[1][forwardsIndex]);
andrew@4: 		indexX--;
andrew@4: 		forwardsIndex++;	   
andrew@4: 	}
andrew@4: 
andrew@4: }
andrew@4: 
andrew@5: void TimeWarp::addNewForwardsPath(int indexX, IntMatrix* backPath, int anchorPointX, int anchorPointY){
andrew@5: 	//pushes back
andrew@5: 	if (indexX < (*backPath)[0].size()){
andrew@5: 	forwardsAlignmentPath[0].push_back((int)(*backPath)[0][indexX]+ anchorPointX);
andrew@5: 	forwardsAlignmentPath[1].push_back((int)(*backPath)[1][indexX] + anchorPointY);
andrew@4: 	}
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: 
andrew@5: void TimeWarp::copyForwardsPathToBackwardsPath(){
andrew@5: 
andrew@5: 	backwardsAlignmentPath.clear();
andrew@5: 	
andrew@5: 	int index = forwardsAlignmentPath[0].size()-1;
andrew@5: 	printf("COPY FORWARDS INDEX %i\n", index);
andrew@5: 	IntVector d;
andrew@5: 	d.push_back(forwardsAlignmentPath[0][index]);
andrew@5: 	backwardsAlignmentPath.push_back(d);
andrew@5: 	d.clear();
andrew@5: 	d.push_back(forwardsAlignmentPath[1][index]);
andrew@5: 	backwardsAlignmentPath.push_back(d);
andrew@5: 	
andrew@5: 	while (index > 0){
andrew@5: 		index--;
andrew@5: 	//	IntVector d;
andrew@5: 	//	d.push_back(forwardsAlignmentPath[0][index]);
andrew@5: 	//	d.push_back(forwardsAlignmentPath[1][index]);
andrew@5: 		backwardsAlignmentPath[0].push_back(forwardsAlignmentPath[0][index]);
andrew@5: 		backwardsAlignmentPath[1].push_back(forwardsAlignmentPath[1][index]);
andrew@5: 	}
andrew@5: 	
andrew@5: }
andrew@5: 
andrew@5: /*
andrew@5: //DONT NEED THIS
andrew@4: void TimeWarp::calculatePartMinimumAlignmentPath(int startX, int startY, int endX, int endY, DoubleMatrix alignmentMatrix){
andrew@4: 	//this requires one pass of the DTW algorithm and then works backwards from (N,M)
andrew@4: 	//to find the optimal path to (0,0), where N and M are the lengths of the two chromoVectors respectively
andrew@4: 	
andrew@4: 	partBackwardsAlignmentPath.clear();
andrew@4: 	
andrew@4: 	printf("Finding PART minimum Path %i vs sim size %i\n", (int)chromaMatrix.size(), (int)similarityMatrix.size() );
andrew@4: 	
andrew@4: 	if (endX < similarityMatrix.size()){
andrew@4: 		IntVector v;
andrew@4: 		v.push_back(endX);
andrew@4: 		partBackwardsAlignmentPath.push_back(v);
andrew@4: 		
andrew@4: 		v.clear();
andrew@4: 	
andrew@4: 		if (endY < similarityMatrix[0].size()){
andrew@4: 		v.push_back(endY);
andrew@4: 		partBackwardsAlignmentPath.push_back(v);
andrew@4: 		}
andrew@4: 	//so now backwards path[0][0] = endX and path[1][0] = endY
andrew@4: 		
andrew@4: 	printf("PART backwards path %i : %i \n", partBackwardsAlignmentPath[0][0], partBackwardsAlignmentPath[1][0]);
andrew@4: 	int indexOfPartBackwardsPath = 0;
andrew@5: 	
andrew@4: 	
andrew@4: 	while (!findPreviousMinimumInBackwardsPath())	{
andrew@4: 		indexOfBackwardsPath++;
andrew@4: 		//		printf("backwards path %i : %i \n", backwardsAlignmentPath[0][indexOfBackwardsPath], backwardsAlignmentPath[1][indexOfBackwardsPath]);
andrew@4: 		
andrew@4: 	}
andrew@5: 	 
andrew@4: 	printf("final index of backwards path is %i and i is %i \n", (int) backwardsAlignmentPath[0].size()-1, indexOfPartBackwardsPath);
andrew@4: 	}//end  if endX within size
andrew@4: 	
andrew@4: 	//	backwardsAlignmentIndex = backwardsAlignmentPath[0].size()-1;//remember that this goes backwards!
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@5: */
andrew@4: 
andrew@4: 
andrew@4: int TimeWarp::findMinimumOfVector(DoubleVector *d){
andrew@4: 	int minimumIndex = 0;
andrew@4: 	double minimumValue = (*d)[0];
andrew@4: 	for (int i = 0;i < d->size();i++){
andrew@4: 		if ((*d)[i] < minimumValue){
andrew@4: 			minimumIndex = i;
andrew@4: 			minimumValue = (*d)[i];
andrew@4: 		}
andrew@4: 	}
andrew@4: 	
andrew@4: 	return minimumIndex;
andrew@4: }
andrew@4: 
andrew@5: 
andrew@5: 
andrew@5: int TimeWarp::findMinimumOfMatrixColumn(DoubleMatrix d, int column){
andrew@5: 	int minimumIndex = 0;
andrew@5: 	
andrew@5: 	double minimumValue = d[column][0];
andrew@5: 	for (int i = 0;i < d.size();i++){
andrew@5: 		if (d[column][i] < minimumValue){
andrew@5: 			minimumIndex = i;
andrew@5: 			minimumValue = d[column][i];
andrew@5: 		}
andrew@5: 	}
andrew@5: 	
andrew@5: 	return minimumIndex;
andrew@5: }
andrew@5: 
andrew@5: 
andrew@5: 
andrew@4: double TimeWarp::getDistance(int i, int j){
andrew@4: 	return (1 - similarityMatrix[i][j]);
andrew@4: }
andrew@4: 
andrew@4: double TimeWarp::getMinimum(int i, int j, float newValue){
andrew@4: 	double minimumValue = 0;
andrew@4: 	
andrew@4: 	if (i > 0){
andrew@4: 		minimumValue = alignmentMeasureMatrix[i-1][j];
andrew@4: 		if (j > 0){
andrew@4: 			minimumValue = min(minimumValue, alignmentMeasureMatrix[i-1][j-1] + newValue ) ;//penalises diagonal by 2
andrew@4: 			minimumValue = min(minimumValue, alignmentMeasureMatrix[i][j-1]);
andrew@4: 		}
andrew@4: 	}
andrew@4: 	else{//i.e. i == 0 
andrew@4: 		if (j > 0)
andrew@4: 			minimumValue = alignmentMeasureMatrix[i][j-1];
andrew@4: 	}
andrew@4: 	
andrew@4: 	return minimumValue;
andrew@4: }
andrew@4: 
andrew@4: 
andrew@5: 
andrew@5: 
andrew@5: double TimeWarp::getDistanceFromMatrix(int i, int j, DoubleMatrix* simMatrix){
andrew@5: 	//	return (1 - (*simMatrix)[i][j]);
andrew@5: 	
andrew@5: 	if (i < (*simMatrix).size() && j < (*simMatrix)[i].size()){
andrew@5: 	//	printf("distance returning %i% i : %f\n", i, j, (1 - (*simMatrix)[i][j]) );
andrew@5: 		return (1 - (*simMatrix)[i][j]);
andrew@5: 	}
andrew@5: 	else{
andrew@5: 		printf("ERROR IN MATRIX CALCULATION - OUT OF LIMITS! %i, %i, size of sim matrix: %ix%i\n", i, j, (int)(*simMatrix).size(), (int)(*simMatrix)[i].size());
andrew@5: 		return 0;
andrew@5: 	}
andrew@5: 	 
andrew@5: }
andrew@5: 
andrew@5: double TimeWarp::getMinimumFromMatrix(int i, int j, float newValue, DoubleMatrix* alignMatrix){
andrew@5: 	double minimumValue = 0;
andrew@5: 	if (i > 0){
andrew@5: 		minimumValue = (*alignMatrix)[i-1][j];
andrew@5: 		if (j > 0){
andrew@15: 			//minimumValue = min(minimumValue, (*alignMatrix)[i-1][j-1] + newValue ) ;//penalises diagonal by 2
andrew@15: 			minimumValue = min(minimumValue, (*alignMatrix)[i-1][j-1]  ) ;//favours diagonal
andrew@5: 			minimumValue = min(minimumValue, (*alignMatrix)[i][j-1]);
andrew@5: 		}
andrew@5: 	}
andrew@5: 	else{//i.e. i == 0 
andrew@5: 		if (j > 0)
andrew@5: 			minimumValue = (*alignMatrix)[i][j-1];
andrew@5: 	}
andrew@5: 	return minimumValue;
andrew@5: }
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: 
andrew@5: int TimeWarp::getMinimumIndexOfColumnFromMatrix(int i, DoubleMatrix* matrix){
andrew@5: 	int minimumIndex = 0;
andrew@5: 	double minimumValue;
andrew@5: 	if (i >= 0 && i < (*matrix).size()){
andrew@5: 		int height = (*matrix)[i].size();
andrew@5: 		int j = 0;
andrew@5: 		minimumValue = (*matrix)[i][j];
andrew@5: 		while (j < height){
andrew@5: 			if ((*matrix)[i][j] < minimumValue){
andrew@5: 			minimumIndex = j;
andrew@5: 			minimumValue = (*matrix)[i][j];
andrew@5: 			}//end if new value
andrew@5: 			j++;
andrew@5: 		}
andrew@5: 	}else{
andrew@5: 		printf("ERROR FROM GETTING MINIMIM!!! - zero - out of bounds, received %i and size is %i\n", i, (*matrix).size());
andrew@5: 	}
andrew@5: 		return minimumIndex;
andrew@5: }
andrew@5: 
andrew@5: 
andrew@5: 
andrew@4: double TimeWarp::getRestrictedMinimum(int i, int j, float newValue, int minX, int minY){
andrew@4: 	double minimumValue = 0;
andrew@4: 	
andrew@4: 	if (i > minX){
andrew@4: 		minimumValue = alignmentMeasureMatrix[i-1][j];
andrew@4: 		if (j > minY){
andrew@4: 			minimumValue = min(minimumValue, alignmentMeasureMatrix[i-1][j-1] + newValue ) ;//penalises diagonal by 2
andrew@4: 			minimumValue = min(minimumValue, alignmentMeasureMatrix[i][j-1]);
andrew@4: 		}
andrew@4: 	}
andrew@4: 	else{//i.e. i == 0 
andrew@4: 		if (j > minY)
andrew@4: 			minimumValue = alignmentMeasureMatrix[i][j-1];
andrew@4: 	}
andrew@4: 	
andrew@4: 	return minimumValue;
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: //--------------part backwards alignment------------------------
andrew@5: /*
andrew@4: bool TimeWarp::findPreviousMinimumInPartBackwardsPath(){
andrew@4: 	
andrew@4: 	int firstPosition, secondPosition;
andrew@4: 	int i,j;
andrew@4: 	i = backwardsAlignmentPath[0][backwardsAlignmentPath[0].size()-1];
andrew@4: 	j  = backwardsAlignmentPath[1][backwardsAlignmentPath[1].size()-1];
andrew@4: 	
andrew@4: 	double newMinimum;
andrew@4: 	double *ptr;
andrew@4: 	ptr = &newMinimum;
andrew@4: 	newMinimum = alignmentMeasureMatrix[i][j];
andrew@4: 	DoubleVector d;
andrew@4: 	
andrew@4: 	
andrew@4: 	bool finishedAligning = true;
andrew@4: 	
andrew@4: 	if (i > 0){
andrew@4: 		if (testForNewAlignmentMinimum(ptr, i-1, j)){
andrew@4: 			firstPosition = i-1;
andrew@4: 			secondPosition = j;
andrew@4: 			finishedAligning = false;
andrew@4: 		}
andrew@4: 		
andrew@4: 		if (j>0 && testForNewAlignmentMinimum(ptr, i-1, j-1)){
andrew@4: 			firstPosition = i-1;
andrew@4: 			secondPosition = j-1;
andrew@4: 			finishedAligning = false;
andrew@4: 		}
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (j > 0 && testForNewAlignmentMinimum(ptr, i, j-1)){
andrew@4: 		firstPosition = i;
andrew@4: 		secondPosition = j-1;
andrew@4: 		//newMinimum = alignmentMeasureMatrix[chromaPosition][secondPosition];
andrew@4: 		finishedAligning = false;
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (!finishedAligning){
andrew@4: 		backwardsAlignmentPath[0].push_back(firstPosition);
andrew@4: 		backwardsAlignmentPath[1].push_back(secondPosition);
andrew@4: 	}
andrew@4: 	
andrew@4: 	return finishedAligning;
andrew@4: 	
andrew@4: }	
andrew@4: 
andrew@5: */
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: /*
andrew@4: void TimeWarp::update(){
andrew@4: 	textString = "energy index [";
andrew@4: 	textString += ofToString(xIndex);
andrew@4: 	textString += "] = ";
andrew@4: 	textString += ofToString(energy[xIndex]);
andrew@4: 	
andrew@4: 	chordString = "Chord : ";
andrew@4: 	chordString += ofToString(rootChord[currentPlayingFrame/CHROMA_CONVERSION_FACTOR]);
andrew@4: 	
andrew@4: 	if (firstAudioFilePlaying){
andrew@4: 		audioPosition = (*playingAudio).getPosition() * firstEnergyVector.size();
andrew@4: 		updateAlignmentPathIndex(0);
andrew@4: 	}
andrew@4: 	else {
andrew@4: 		audioPosition = (*playingAudio).getPosition() * secondEnergyVector.size();	
andrew@4: 		updateAlignmentPathIndex(1);
andrew@4: 	}
andrew@4: 	
andrew@4: 	//if(!audioPaused)
andrew@4: 	//printScoreForRow(audioPosition/CHROMA_CONVERSION_FACTOR, (audioPosition/CHROMA_CONVERSION_FACTOR)+10);
andrew@4: 	
andrew@4: 	//the position in number of frames
andrew@4: 	//totalNumberOfFrames was used but is the most recently loaded file length
andrew@4: 	
andrew@4: 	currentPlayingFrame = audioPosition;
andrew@4: 	audioPosition = (int) audioPosition % scrollWidth ;
andrew@4: 	audioPosition /= scrollWidth;
andrew@4: 	
andrew@4: 	ofSoundUpdate();
andrew@4: 	
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: 
andrew@4: /*
andrew@4:  void TimeWarp::updateAlignmentPathIndex(int identifier){
andrew@4: 	
andrew@4: //	int chromaPosition = audioPosition/CHROMA_CONVERSION_FACTOR;
andrew@4: 	
andrew@4: 	while (backwardsAlignmentPath[identifier][backwardsAlignmentIndex] < chromaPosition)
andrew@4: 	{
andrew@4: 		backwardsAlignmentIndex--;
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4:  */
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: /*
andrew@4:  void TimeWarp::draw(){
andrew@4: 	
andrew@4: 	if (drawSimilarity)
andrew@4: 		drawSimilarityMatrix();
andrew@4: 	else
andrew@4: 		drawChromoGram();
andrew@4: 	
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: void TimeWarp::drawEnergyVectorFromPointer(DoubleVector* energyVec){
andrew@4: 	
andrew@4: 	float screenHeight = ofGetHeight() ;
andrew@4: 	float screenWidth = ofGetWidth();  
andrew@4: 	float heightFactor = 8;
andrew@4: 	int i, j, startingFrame;
andrew@4: 	startingFrame = currentPlayingFrame / scrollWidth;//i.e. number of scroll widths in
andrew@4: 	startingFrame *= scrollWidth;
andrew@4: 	
andrew@4: 	for (i = 0; i < scrollWidth - 1; i++){
andrew@4: 		j = i + startingFrame;
andrew@4: 		ofLine(i*screenWidth/scrollWidth, screenHeight - ((*energyVec)[j]*screenHeight/heightFactor),
andrew@4: 			   screenWidth*(i+1)/scrollWidth, screenHeight - ((*energyVec)[j+1]*screenHeight/heightFactor));
andrew@4: 		
andrew@4: 	}
andrew@4: }
andrew@4: 
andrew@4: void TimeWarp::drawSpectralDifference(DoubleMatrix* dMatrix){
andrew@4: 	if ((*dMatrix).size()>0){
andrew@4: 		
andrew@4: 		float screenHeight = ofGetHeight() ;
andrew@4: 		float screenWidth = ofGetWidth();
andrew@4: 		float heightFactor = 8;
andrew@4: 		double difference;
andrew@4: 		int i, j, startingFrame;
andrew@4: 		startingFrame = currentPlayingFrame / scrollWidth;//i.e. number of scroll widths in
andrew@4: 		startingFrame *= scrollWidth;//starting frame in terms of energy frames
andrew@4: 		startingFrame /= CHROMA_CONVERSION_FACTOR; //in terms of chroma frames
andrew@4: 		
andrew@4: 		
andrew@4: 		for (i = 1; i < chromoLength; i++){//changed to add 1
andrew@4: 			j = i + startingFrame;
andrew@4: 			for (int y = 0;y < 12;y++){			
andrew@4: 				difference = (*dMatrix)[j][11-y] - (*dMatrix)[j-1][11-y];
andrew@4: 				if (difference < 0)
andrew@4: 					difference = 0;//half wave rectify
andrew@4: 				
andrew@4: 				ofSetColor(0,0,255 * difference);//, 0;
andrew@4: 				ofRect(i*screenWidth/chromoLength,y*screenHeight/12,screenWidth/chromoLength,screenHeight/12);
andrew@4: 			}//end y
andrew@4: 		}//end i
andrew@4: 		
andrew@4: 	}///end if matrix has content
andrew@4: 	else{
andrew@4: 		printf("Error - please load audio first");
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: void TimeWarp::drawChromoGram(){
andrew@4: 	
andrew@4: 	DoubleMatrix* dptr;
andrew@4: 	DoubleVector* eptr;
andrew@4: 	string whichFileString;
andrew@4: 	
andrew@4: 	if (drawSecondMatrix){
andrew@4: 		
andrew@4: 		dptr = &secondMatrix;
andrew@4: 		
andrew@4: 		eptr = &secondEnergyVector;
andrew@4: 		
andrew@4: 		whichFileString = "second file";
andrew@4: 		
andrew@4: 	}else {
andrew@4: 		
andrew@4: 		dptr = &chromaMatrix;
andrew@4: 		eptr = &firstEnergyVector;
andrew@4: 		whichFileString = "first file";
andrew@4: 	}
andrew@4: 	
andrew@4: 	
andrew@4: 	
andrew@4: 	if (drawSpectralDifferenceFunction)
andrew@4: 		drawSpectralDifference(dptr);
andrew@4: 	else
andrew@4: 		drawDoubleMatrix(dptr);
andrew@4: 	
andrew@4: 	ofSetColor(0xFF6666);
andrew@4: 	drawEnergyVectorFromPointer(eptr);
andrew@4: 	
andrew@4: 	ofDrawBitmapString(textString,80,480);
andrew@4: 	
andrew@4: 	
andrew@4: 	ofSetColor(0xFFFFFF);
andrew@4: 	ofLine(audioPosition*width, 0, audioPosition*width, height);
andrew@4: 	
andrew@4: 	
andrew@4: 	ofDrawBitmapString(chordString,80,580);
andrew@4: 	
andrew@4: 	ofDrawBitmapString(soundFileName,80,480);
andrew@4: 	
andrew@4: 	ofDrawBitmapString(whichFileString,80,80);
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: void TimeWarp::drawDoubleMatrix(DoubleMatrix* dMatrix){
andrew@4: 	if ((*dMatrix).size()>0){
andrew@4: 		
andrew@4: 		float screenHeight = ofGetHeight() ;
andrew@4: 		float screenWidth = ofGetWidth();
andrew@4: 		float heightFactor = 8;
andrew@4: 		int i, j, startingFrame;
andrew@4: 		startingFrame = currentPlayingFrame / scrollWidth;//i.e. number of scroll widths in
andrew@4: 		startingFrame *= scrollWidth;//starting frame in terms of energy frames
andrew@4: 		startingFrame /= CHROMA_CONVERSION_FACTOR; //in terms of chroma frames
andrew@4: 		
andrew@4: 		float chromoLength = scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 		for (i = 0; i < chromoLength; i++){
andrew@4: 			j = i + startingFrame;
andrew@4: 			for (int y = 0;y < 12;y++){
andrew@4: 				ofSetColor(0,0,255 * (*dMatrix)[j][11-y]);//, 0;
andrew@4: 				ofRect(i*screenWidth/chromoLength,y*screenHeight/12,screenWidth/chromoLength,screenHeight/12);
andrew@4: 			}//end y
andrew@4: 		}//end i
andrew@4: 		
andrew@4: 	}///end if matrix has content
andrew@4: 	else{
andrew@4: 		printf("Error - please load audio first");
andrew@4: 	}
andrew@4: 	
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: void TimeWarp::drawSimilarityMatrix(){
andrew@4: 	
andrew@4: 	int simHeight = (similarityMatrix[0]).size();
andrew@4: 	int simWidth = similarityMatrix.size();
andrew@4: 	
andrew@4: 	int sizeOfMatrix = chromaMatrix.size();
andrew@4: 	int sizeOfSecondMatrix = secondMatrix.size();
andrew@4: 	
andrew@4: 	int startingXframe = backwardsAlignmentPath[0][backwardsAlignmentIndex] / (scrollWidth/CHROMA_CONVERSION_FACTOR);
andrew@4: 	int startingYframe = backwardsAlignmentPath[1][backwardsAlignmentIndex] / (scrollWidth/CHROMA_CONVERSION_FACTOR);
andrew@4: 	
andrew@4: 	int startingFrame = findStartWidthFrame();
andrew@4: 	startingFrame = numberOfScrollWidthsForFirstFile * scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 	
andrew@4: 	startingXframe = startingXframe * scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 	startingYframe = startingYframe * scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 	//need to fix for second file too
andrew@4: 	
andrew@4: 	int *indexOfAlignmentPathTested;
andrew@4: 	int lengthOfPath = backwardsAlignmentPath[0].size()-1;
andrew@4: 	indexOfAlignmentPathTested = &lengthOfPath;
andrew@4: 	
andrew@4: 	int xcoord;
andrew@4: 	for (int x = 0;x < screenWidth;x++)
andrew@4: 	{
andrew@4: 		for (int y =0;y < screenHeight;y++){
andrew@4: 			
andrew@4: 			xcoord = (x / screenWidth) * chromoLength;//was simWidth
andrew@4: 			//xcoord += startingFrame;
andrew@4: 			xcoord += startingXframe;
andrew@4: 			
andrew@4: 			int ycoord = y * chromoLength/ screenHeight;
andrew@4: 			//ycoord += startingFrame;
andrew@4: 			ycoord += startingYframe;
andrew@4: 			
andrew@4: 			int colour = 0;
andrew@4: 			//int ycoord = y * simHeight/ screenHeight;
andrew@4: 			//y += startingFrame;
andrew@4: 			if (xcoord < sizeOfMatrix && ycoord < sizeOfSecondMatrix)
andrew@4: 				colour = similarityMatrix[xcoord][ycoord]*255;
andrew@4: 			
andrew@4: 			
andrew@4: 			ofSetColor(colour,0,0);
andrew@4: 			
andrew@4: 			ofRect(x,y,1,1);
andrew@4: 			
andrew@4: 		}
andrew@4: 	}
andrew@4: 	
andrew@4: 	drawAlignmentPath(startingXframe, startingYframe);
andrew@4: 	
andrew@4: 	//SET TEXT
andrew@4: 	string textString;
andrew@4: 	textString = "width : ";
andrew@4: 	textString += ofToString(simWidth);
andrew@4: 	
andrew@4: 	textString += "  height : ";
andrew@4: 	textString += ofToString(simHeight);
andrew@4: 	
andrew@4: 	textString += "  startframe : ";
andrew@4: 	textString += ofToString(startingFrame);
andrew@4: 	
andrew@4: 	textString += "  Xframe : ";
andrew@4: 	textString += ofToString(startingXframe);
andrew@4: 	
andrew@4: 	textString += "  Yframe : ";
andrew@4: 	textString += ofToString(startingYframe);
andrew@4: 	
andrew@4: 	textString += "  currentFrame : ";
andrew@4: 	textString += ofToString(currentPlayingFrame);
andrew@4: 	
andrew@4: 	textString += "  scrollwidth: ";
andrew@4: 	textString += ofToString(scrollWidth);
andrew@4: 	
andrew@4: 	textString += "  xcoord: ";
andrew@4: 	textString += ofToString(xcoord);
andrew@4: 	
andrew@4: 	textString += "  Clength: ";
andrew@4: 	textString += ofToString(chromoLength);
andrew@4: 	
andrew@4: 	textString += "  no.Scrolls: ";
andrew@4: 	textString += ofToString(numberOfScrollWidthsForFirstFile);
andrew@4: 	//END SET TEXT
andrew@4: 	
andrew@4: 	ofSetColor(0x0000FF);
andrew@4: 	if (firstAudioFilePlaying){
andrew@4: 		ofLine(audioPosition*screenWidth, 0, audioPosition*screenWidth, height);
andrew@4: 		checkIfAudioPositionExceedsWidthForFirstFile();	
andrew@4: 		
andrew@4: 		//draw values:
andrew@4: 		xcoord = currentPlayingFrame / CHROMA_CONVERSION_FACTOR;
andrew@4: 		ofSetColor(255, 255, 255);
andrew@4: 		for (int y = 0;y < chromoLength; y+=max(1, (int)(20 * chromoLength / screenHeight))){
andrew@4: 			
andrew@4: 			float value = alignmentMeasureMatrix[xcoord][y+startingYframe];
andrew@4: 			int ycoord = y * screenHeight/chromoLength;
andrew@4: 			ofDrawBitmapString(ofToString(value, 2) , audioPosition*screenWidth , ycoord);
andrew@4: 		}
andrew@4: 	}
andrew@4: 	else{
andrew@4: 		ofLine(0, audioPosition*screenHeight, screenWidth, audioPosition*screenHeight);	
andrew@4: 	}
andrew@4: 	
andrew@4: 	ofDrawBitmapString(textString,80,580);
andrew@4: 	
andrew@4: 	ofDrawBitmapString(userInfoString,80,80);
andrew@4: 	
andrew@4: }
andrew@4:  
andrew@4:  
andrew@4:  
andrew@4:  void TimeWarp::drawAlignmentPath(int startingChromaXFrame, int startingChromaYFrame){
andrew@4:  //draw alignment path
andrew@4:  int endingChromaXFrame = startingChromaXFrame + chromoLength;
andrew@4:  int endingChromaYFrame = startingChromaYFrame + chromoLength;
andrew@4:  
andrew@4:  float chromoWidth = screenWidth / chromoLength;
andrew@4:  float chromoHeight = screenHeight / chromoLength;
andrew@4:  
andrew@4:  int index = backwardsAlignmentPath[0].size()-1;
andrew@4:  //OPTIMISE XXX
andrew@4:  
andrew@4:  
andrew@4:  while (backwardsAlignmentPath[0][index] < startingChromaXFrame){
andrew@4:  index --;
andrew@4:  }
andrew@4:  
andrew@4:  int printIndex = index;
andrew@4:  int backAlign = backwardsAlignmentPath[0][index];
andrew@4:  int printxcoord;
andrew@4:  int xcoord;
andrew@4:  
andrew@4:  while (backwardsAlignmentPath[0][index] < endingChromaXFrame) {
andrew@4:  xcoord = backwardsAlignmentPath[0][index];
andrew@4:  int ycoord = backwardsAlignmentPath[1][index];
andrew@4:  
andrew@4:  printxcoord = xcoord;
andrew@4:  int colour = similarityMatrix[xcoord][ycoord]*255;
andrew@4:  
andrew@4:  float value = alignmentMeasureMatrix[xcoord][ycoord] ;
andrew@4:  
andrew@4:  
andrew@4:  xcoord -= startingChromaXFrame;
andrew@4:  ycoord -= startingChromaYFrame;
andrew@4:  ofSetColor(0,0,colour);
andrew@4:  ofRect(xcoord*chromoWidth, ycoord*chromoHeight, chromoWidth, chromoHeight);
andrew@4:  //		ofSetColor(255, 255, 255);
andrew@4:  //		ofDrawBitmapString(ofToString(value, 2), xcoord*chromoWidth, ycoord*chromoHeight);
andrew@4:  index--;
andrew@4:  }
andrew@4:  
andrew@4:  //	drawHoverAlignmentValues();
andrew@4:  //	printf("ALIGN score :[%i] : %f \n", backwardsAlignmentPath[1][backwardsAlignmentIndex], alignmentMeasureMatrix[ backwardsAlignmentPath[0][backwardsAlignmentIndex] ][ (int) backwardsAlignmentPath[1][backwardsAlignmentIndex] ]);
andrew@4:  
andrew@4:  
andrew@4:  //SET TEXT
andrew@4:  string textString;
andrew@4:  textString = "ALIGNMENT PATH  ";
andrew@4:  
andrew@4:  textString += "backward A index ";
andrew@4:  textString += ofToString(backwardsAlignmentIndex);
andrew@4:  
andrew@4:  textString += "  starting X frame ";
andrew@4:  textString += ofToString(startingChromaXFrame);
andrew@4:  
andrew@4:  textString += "  initial xcoord ";
andrew@4:  textString += ofToString(printxcoord);
andrew@4:  
andrew@4:  textString += "  first index ";
andrew@4:  textString += ofToString(printIndex);
andrew@4:  
andrew@4:  textString += "  backalign[index] ";
andrew@4:  textString += ofToString(backAlign);
andrew@4:  
andrew@4:  textString += "  final xcoord ";
andrew@4:  textString += ofToString(xcoord);
andrew@4:  
andrew@4:  
andrew@4:  
andrew@4:  
andrew@4:  ofSetColor(255,255,255); 
andrew@4:  ofDrawBitmapString(textString,80,640);
andrew@4:  
andrew@4:  }
andrew@4:  
andrew@4:  
andrew@4:  
andrew@4: */
andrew@4: /*
andrew@4: void  TimeWarp::checkIfAudioPositionExceedsWidthForFirstFile()
andrew@4: {
andrew@4: 	if (currentPlayingFrame > scrollWidth*(numberOfScrollWidthsForFirstFile+1))
andrew@4: 		numberOfScrollWidthsForFirstFile++;
andrew@4: }
andrew@4: 
andrew@4: int TimeWarp::findStartWidthFrame(){
andrew@4: 	int startingFrame;
andrew@4: 	startingFrame = currentPlayingFrame / scrollWidth;//i.e. number of scroll widths in
andrew@4: 	startingFrame *= scrollWidth;//starting frame in terms of energy frames
andrew@4: 	startingFrame /= CHROMA_CONVERSION_FACTOR; 
andrew@4: 	
andrew@4: 	return startingFrame;
andrew@4: }
andrew@4: 
andrew@4: */
andrew@4: 
andrew@4: /*
andrew@4: void TimeWarp::loadSoundFiles(){
andrew@4: 	
andrew@4: 	//assume libsndfile looks in the folder where the app is run
andrew@4: 	//therefore ../../../ gets to the bin folder
andrew@4: 	//we then need data/sounds/to get to the sound folder
andrew@4: 	//this is different to the usual OF default folder
andrew@4: 	//was const char	
andrew@4: 	const char	*infilename = "../../../data/sound/1-01BachBWV 846.wav";	
andrew@4: 	loadLibSndFile(infilename);
andrew@4: 	
andrew@4: 	string loadfilename = "sound/1-01BachBWV 846.wav";//PicturesMixer6.aif";	
andrew@4: 	loadedAudio.loadSound(loadfilename);
andrew@4: 	playingAudio = &loadedAudio;
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: void TimeWarp::loadLibSndFile(const char *infilename){
andrew@4: 	
andrew@4: 	if (!sf_close(infile)){
andrew@4: 		printf("closed sndfile okay \n");
andrew@4: 	}
andrew@4: 	
andrew@4: 	// Open Input File with lib snd file
andrew@4:     if (! (infile = sf_open (infilename, SFM_READ, &sfinfo)))
andrew@4:     {   // Open failed
andrew@4:         printf ("SF OPEN routine Not able to open input file %s.\n", infilename) ;
andrew@4:         // Print the error message from libsndfile. 
andrew@4:         puts (sf_strerror (NULL)) ;
andrew@4: 		
andrew@4: 	} else{
andrew@4: 		printf("SF OPEN opened file %s okay.\n", infilename);
andrew@4: 		sndfileInfoString = "Opened okay ";
andrew@4: 		
andrew@4: 	};
andrew@4: 	
andrew@4: }
andrew@4:  */
andrew@4: /*
andrew@4: void TimeWarp::processAudioToDoubleMatrix(Chromagram* chromaG, DoubleMatrix* myDoubleMatrix, DoubleVector* energyVector){
andrew@4: 	//wendy
andrew@4: 	myDoubleMatrix->clear();
andrew@4: 	energyVector->clear();
andrew@4: 	
andrew@4: 	energyIndex = 0;
andrew@4: 	
andrew@4: 	chromaG->initialise(FRAMESIZE,2048);//framesize 512 and hopsize 2048 
andrew@4: 	chromaG->maximumChromaValue = 0;
andrew@4: 	
andrew@4: 	int readcount = 1; // counts number of samples read from sound file
andrew@4: 	printf("processing audio from doublematrix \n");
andrew@4: 	printf("readcount %i", readcount);
andrew@4: 	while(readcount != 0 && moveOn == true)
andrew@4: 	{
andrew@4: 		
andrew@4: 		// read FRAMESIZE samples from 'infile' and save in 'data'
andrew@4: 		readcount = sf_read_float(infile, frame, FRAMESIZE);
andrew@4: 		//processing frame - downsampled to 11025Hz
andrew@4: 		//8192 samples per chroma frame
andrew@4: 		
andrew@4: 		chromaG->processframe(frame);
andrew@4: 		
andrew@4: 		if (chromaG->chromaready)
andrew@4: 		{
andrew@4: 			DoubleVector d;
andrew@4: 			
andrew@4: 			for (int i = 0;i<12;i++){
andrew@4: 				//chromoGramVector[chromaIndex][i] = chromoGramm.rawChroma[i] / chromoGramm.maximumChromaValue;
andrew@4: 				d.push_back(chromaG->rawChroma[i]);// / chromaG->maximumChromaValue);	
andrew@4: 				
andrew@4: 			}	
andrew@4: 			//this would do chord detection
andrew@4: 			
andrew@4: 			myDoubleMatrix->push_back(d);
andrew@4: 			
andrew@4: 			
andrew@4: 		}//end if chromagRamm ready
andrew@4: 		
andrew@4: 
andrew@4: 		
andrew@4: 		putEnergyInFrame();
andrew@4: 		//get energy of the current frame and wait
andrew@4: 		double energyValue = getEnergyOfFrame();
andrew@4: 		energyVector->push_back(energyValue);
andrew@4: 		
andrew@4: 		
andrew@4: 	}//end while readcount
andrew@4: 	
andrew@4: 	printf("Max chroma value is %f \n", chromaG->maximumChromaValue);
andrew@4: 	
andrew@4: 	//normalise
andrew@4: 	int length = myDoubleMatrix->size();
andrew@4: 	printf("length of chromagram is %d frames\n", length);
andrew@4: 	length = (*myDoubleMatrix)[0].size();
andrew@4: 	printf("height of dmatrix is %d\n", length);
andrew@4: 	
andrew@4: 	for (int i = 0; i < myDoubleMatrix->size();i++){
andrew@4: 		for (int j = 0; j < ((*myDoubleMatrix)[0]).size();j++){
andrew@4: 			(*myDoubleMatrix)[i][j] /= chromaG->maximumChromaValue;	
andrew@4: 		}
andrew@4: 	}
andrew@4: 	
andrew@4: 	int size;
andrew@4: 	size = energyVector->size();
andrew@4: 	printf("size of energy vector is %d \n", size);
andrew@4: 	
andrew@4: 	
andrew@4: 	//	int size = myDoubleMatrix->size() * CHROMA_CONVERSION_FACTOR;
andrew@4: 	//	printf("size of double matrix is %d and frame index %d", size, frameIndex);
andrew@4: 	
andrew@4: //	printf("Total frames %i energy index %i and Chroma index %i \n", frameIndex, energyIndex, chromaIndex);
andrew@4: 	
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: /*
andrew@4: void TimeWarp::keyPressed  (int key){
andrew@4: 	if (key == '-'){
andrew@4: 		volume -= 0.05;
andrew@4: 		volume = MAX(volume, 0);
andrew@4: 	} else if (key == '+'){
andrew@4: 		volume += 0.05;
andrew@4: 		volume = MIN(volume, 1);
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == OF_KEY_DOWN){
andrew@4: 		if (scrollWidth > 600)
andrew@4: 			scrollWidth += 400;
andrew@4: 		else
andrew@4: 			scrollWidth *= 2;
andrew@4: 		
andrew@4: 		chromoLength = scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == OF_KEY_UP){
andrew@4: 		if (scrollWidth > 600)
andrew@4: 			scrollWidth -= 400;
andrew@4: 		else
andrew@4: 			scrollWidth /= 2;
andrew@4: 		
andrew@4: 		chromoLength = scrollWidth/CHROMA_CONVERSION_FACTOR;
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == OF_KEY_LEFT){
andrew@4: 		
andrew@4: 		(*playingAudio).setSpeed(-2);
andrew@4: 		backwardsAlignmentIndex = backwardsAlignmentPath[0].size()-1;
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == OF_KEY_RIGHT){
andrew@4: 		
andrew@4: 		(*playingAudio).setSpeed(2);
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == OF_KEY_RETURN){
andrew@4: 		loadedAudio.stop();
andrew@4: 		audioPlaying = false;
andrew@4: 		audioPaused = true;
andrew@4: 		initialiseVariables();
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == ' '){
andrew@4: 		if (!audioPlaying) {
andrew@4: 			(*playingAudio).play();
andrew@4: 			(*playingAudio).setPaused(false);
andrew@4: 			secondAudio.play();
andrew@4: 			secondAudio.setPaused(true);
andrew@4: 			
andrew@4: 			firstAudioFilePlaying = true; 
andrew@4: 			
andrew@4: 			audioPlaying = true;
andrew@4: 			audioPaused = false;
andrew@4: 		}
andrew@4: 		else{
andrew@4: 			audioPaused = !audioPaused;
andrew@4: 			(*playingAudio).setPaused(audioPaused);
andrew@4: 		}
andrew@4: 		
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == 'p'){
andrew@4: 		swapBetweenPlayingFilesUsingAlignmentMatch();
andrew@4: 		
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == 'o'){
andrew@4: 		openNewAudioFileWithdialogBox();
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == 'l'){
andrew@4: 		//open audio file
andrew@4: 		string *filePtr, secondFileName;
andrew@4: 		filePtr = &secondFileName;
andrew@4: 		//so filePtr points to secondFileName
andrew@4: 		
andrew@4: 		if (getFilenameFromDialogBox(filePtr)){
andrew@4: 			printf("Loaded name okay :\n'%s' \n", secondFileName.c_str());	
andrew@4: 		}
andrew@4: 		
andrew@4: 		loadSecondAudio(secondFileName);
andrew@4: 		
andrew@4: 		calculateSimilarityMatrix();
andrew@4: 		calculateAlignmentMatrix();
andrew@4: 		calculateMinimumAlignmentPath();
andrew@4: 		
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == 's'){
andrew@4: 		drawSimilarity = !drawSimilarity;
andrew@4: 	}
andrew@4: 	
andrew@4: 	
andrew@4: 	if (key == 'm'){
andrew@4: 		drawSecondMatrix = !drawSecondMatrix;
andrew@4: 	}
andrew@4: 	
andrew@4: 	if (key == 'd'){
andrew@4: 		drawSpectralDifferenceFunction = !drawSpectralDifferenceFunction;
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::keyReleased  (int key){
andrew@4: 	if (key == OF_KEY_LEFT || OF_KEY_RIGHT){
andrew@4: 		(*playingAudio).setSpeed(1);
andrew@4: 		backwardsAlignmentIndex = backwardsAlignmentPath[0].size()-1;
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: /*
andrew@4: void TimeWarp::openNewAudioFileWithdialogBox(){
andrew@4: 	
andrew@4: 	//open audio file
andrew@4: 	string *filePtr;
andrew@4: 	filePtr = &soundFileName;	
andrew@4: 	
andrew@4: 	if (getFilenameFromDialogBox(filePtr)){
andrew@4: 		printf("Mainfile: Loaded name okay :\n'%s' \n", soundFileName.c_str());	
andrew@4: 	}
andrew@4: 	
andrew@4: 	//openFileDialogBox(); - replaced this lone by call to openFile Dialoguebox
andrew@4: 	loadNewAudio(soundFileName);
andrew@4: 	
andrew@4: }
andrew@4:  */
andrew@4: /*
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::mouseMoved(int x, int y ){
andrew@4: 	width = ofGetWidth();
andrew@4: 	pan = (float)x / (float)width;
andrew@4: 	float height = (float)ofGetHeight();
andrew@4: 	float heightPct = ((height-y) / height);
andrew@4: 	targetFrequency = 2000.0f * heightPct;
andrew@4: 	phaseAdderTarget = (targetFrequency / (float) sampleRate) * TWO_PI;
andrew@4: 	xIndex = (int)(pan*ENERGY_LENGTH);
andrew@4: }
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::mouseDragged(int x, int y, int button){
andrew@4: 	width = ofGetWidth();
andrew@4: 	pan = (float)x / (float)width;
andrew@4: }
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::mousePressed(int x, int y, int button){
andrew@4: 	bNoise = true;
andrew@4: 	moveOn = true;
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::mouseReleased(int x, int y, int button){
andrew@4: 	bNoise = false;
andrew@4: }
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: void TimeWarp::windowResized(int w, int h){
andrew@4: 	width = w;
andrew@4: 	height = h;
andrew@4: 	screenHeight = ofGetHeight() ;
andrew@4: 	screenWidth = ofGetWidth();
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: 
andrew@4: //--------------------------------------------------------------
andrew@4: /*
andrew@4: 
andrew@4: bool TimeWarp::getFilenameFromDialogBox(string* fileNameToSave){
andrew@4: 	//this uses a pointer structure within the loader and returns true if the dialogue box was used successfully
andrew@4: 	// first, create a string that will hold the URL
andrew@4: 	string URL;
andrew@4: 	
andrew@4: 	// openFile(string& URL) returns 1 if a file was picked
andrew@4: 	// returns 0 when something went wrong or the user pressed 'cancel'
andrew@4: 	int response = ofxFileDialogOSX::openFile(URL);
andrew@4: 	if(response){
andrew@4: 		// now you can use the URL 
andrew@4: 		*fileNameToSave = URL;
andrew@4: 		//printf("\n filename is %s \n", soundFileName.c_str());
andrew@4: 		return true;
andrew@4: 	}
andrew@4: 	else {
andrew@4: 		//	soundFileName = "OPEN canceled. ";
andrew@4: 		printf("\n open file cancelled \n");
andrew@4: 		return false;
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: 
andrew@4: 
andrew@4: /*
andrew@4: void TimeWarp::putEnergyInFrame(){
andrew@4: 	
andrew@4: 	
andrew@4: 	float totalEnergyInFrame = 0;
andrew@4: 	
andrew@4: 	for (int i = 0;i<FRAMESIZE;i++){
andrew@4: 		
andrew@4: 		totalEnergyInFrame += (frame[i] * frame[i]);
andrew@4: 		
andrew@4: 	}
andrew@4: 	totalEnergyInFrame = sqrt(totalEnergyInFrame);
andrew@4: 	
andrew@4: 	if (energyIndex < ENERGY_LENGTH){
andrew@4: 		energy[energyIndex] = totalEnergyInFrame;
andrew@4: 		energyIndex++;
andrew@4: 	}
andrew@4: 	
andrew@4: }
andrew@4:  */
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: /*
andrew@4: void TimeWarp::printAlignmentMatrix(){
andrew@4: 	
andrew@4: 	int size = alignmentMeasureMatrix.size();
andrew@4: 	printf("\n _ _ _ _\n");
andrew@4: 	printf("align size is %i \n", size);
andrew@4: 	
andrew@4: 	int i,j;
andrew@4: 	DoubleVector d;
andrew@4: 	int rowSize = alignmentMeasureMatrix.size();
andrew@4: 	d = alignmentMeasureMatrix[0];//choose initial size
andrew@4: 	
andrew@4: 	for (int j = 0;j < d.size();j++){
andrew@4: 		printf("row %i : ", j);
andrew@4: 		
andrew@4: 		for (i = 0;i < rowSize;i++){
andrew@4: 			d = alignmentMeasureMatrix[i];
andrew@4: 			
andrew@4: 			//	printf("row %i , col %i, val : %f \n", i, j, alignmentMeasureMatrix[i][j] );
andrew@4: 			printf("%f , ", alignmentMeasureMatrix[i][j] );
andrew@4: 		}
andrew@4: 		printf("\n");
andrew@4: 	}
andrew@4: 	printf("...............\n");
andrew@4: 	
andrew@4: }
andrew@4: 
andrew@4: 
andrew@4: void TimeWarp::printScoreForRow(int row, int max){
andrew@4: 	printf("alignment scores row %i \n", row);
andrew@4: 	float minimum = alignmentMeasureMatrix[row][0];
andrew@4: 	int minimumIndex = 0;
andrew@4: 	for (int i =0;i < max;i++){
andrew@4: 		printf("[%i] %f ", i, alignmentMeasureMatrix[row][i]);
andrew@4: 		if (alignmentMeasureMatrix[row][i] < minimum)
andrew@4: 		{
andrew@4: 			minimum = alignmentMeasureMatrix[row][i] ;
andrew@4: 			minimumIndex = i;
andrew@4: 		}
andrew@4: 		printf(" \n");
andrew@4: 	}
andrew@4: 	printf("Minimum [%i] : %f \n", minimumIndex, minimum);
andrew@4: 	printf("ALIGN score :[%i] : %f \n", backwardsAlignmentPath[1][backwardsAlignmentIndex], alignmentMeasureMatrix[ backwardsAlignmentPath[0][backwardsAlignmentIndex] ][ (int) backwardsAlignmentPath[1][backwardsAlignmentIndex] ]);
andrew@4: 	
andrew@4: 	
andrew@4: }
andrew@4: */
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: /*
andrew@4:  void TimeWarp::swapBetweenPlayingFilesUsingAlignmentMatch(){
andrew@4:  ofSoundUpdate();
andrew@4:  //swapping between files
andrew@4:  //printf("current playing (energy scale) frame was %i \n", currentPlayingFrame);
andrew@4:  float oldPosition = (*playingAudio).getPosition();
andrew@4:  printf("playing position is %f \n", (*playingAudio).getPosition());
andrew@4:  
andrew@4:  //(*playingAudio).stop(); 
andrew@4:  (*playingAudio).setPaused(true);
andrew@4:  int newIndicator;
andrew@4:  if (firstAudioFilePlaying){
andrew@4:  playingAudio = &secondAudio;
andrew@4:  newIndicator = 1;	
andrew@4:  }
andrew@4:  else{
andrew@4:  playingAudio = &loadedAudio;
andrew@4:  newIndicator = 0;
andrew@4:  }
andrew@4:  printf("new indicator %i \n", newIndicator);
andrew@4:  
andrew@4:  printf("playing pos according to energy frames is %f \n ", 
andrew@4:  (currentPlayingFrame/((float)backwardsAlignmentPath[1-newIndicator][0]*CHROMA_CONVERSION_FACTOR)) );
andrew@4:  
andrew@4:  printf("predicts frame to be %f \n", (oldPosition*backwardsAlignmentPath[1-newIndicator][0]));
andrew@4:  
andrew@4:  currentChromaFrame = oldPosition * (float) backwardsAlignmentPath[1-newIndicator][0];
andrew@4:  printf("current chroma frame %i and using energy frames would have been %i \n", currentChromaFrame, currentPlayingFrame / CHROMA_CONVERSION_FACTOR);
andrew@4:  int matchingFrame = findMatchFromAlignment(firstAudioFilePlaying);	
andrew@4:  
andrew@4:  float relativePosition = matchingFrame / (float) backwardsAlignmentPath[newIndicator][0];
andrew@4:  //i.e. the position as float [0,1] 0:beginning, 1 is end
andrew@4:  
andrew@4:  (*playingAudio).setPaused(false);
andrew@4:  //	secondAudio.setPosition(relativePosition);//XXX tmp line
andrew@4:  (*playingAudio).setPosition(relativePosition);
andrew@4:  
andrew@4:  printf("matching frame is %i and length is %i \n", matchingFrame, backwardsAlignmentPath[newIndicator][0]);
andrew@4:  printf("new playing position is %f \n", (*playingAudio).getPosition());
andrew@4:  
andrew@4:  firstAudioFilePlaying = !firstAudioFilePlaying;
andrew@4:  
andrew@4:  
andrew@4:  }
andrew@4:  */
andrew@4: /*
andrew@4:  int TimeWarp::findMatchFromAlignment(bool whichFileToTest){
andrew@4:  //could use technique from middle of file and go either way to reduce latency for long search? 
andrew@4:  //- (not that this is a problem yet)
andrew@4:  int indicator;
andrew@4:  if (whichFileToTest)
andrew@4:  indicator = 0;
andrew@4:  else
andrew@4:  indicator = 1;
andrew@4:  
andrew@4:  int oppositeIndicator = 1 - indicator;
andrew@4:  
andrew@4:  int frame = backwardsAlignmentPath[indicator].size()-1;
andrew@4:  
andrew@4:  //	int currentChromaFrame = currentPlayingFrame / CHROMA_CONVERSION_FACTOR;
andrew@4:  //trying this instead
andrew@4:  
andrew@4:  
andrew@4:  
andrew@4:  while (backwardsAlignmentPath[indicator][frame] < currentChromaFrame){
andrew@4:  frame--;
andrew@4:  }
andrew@4:  //printf("frame found is %i \n", frame);
andrew@4:  int frameToSwitchTo = backwardsAlignmentPath[oppositeIndicator][frame];
andrew@4:  
andrew@4:  float calculatedPosition = (currentChromaFrame / (float) backwardsAlignmentPath[indicator][0]);
andrew@4:  
andrew@4:  printf("(length was %i)\n",  backwardsAlignmentPath[indicator][0]);
andrew@4:  
andrew@4:  printf("compares to position calculated from chroma length %f \n", calculatedPosition);
andrew@4:  printf("current frame %i maps to new frame %i \n", currentChromaFrame, frameToSwitchTo);
andrew@4:  printf("relative position of new frame is %f \n", (frameToSwitchTo / (float) backwardsAlignmentPath[oppositeIndicator][0]) );
andrew@4:  return frameToSwitchTo; 
andrew@4:  
andrew@4:  }
andrew@4:  
andrew@4:  */
andrew@4: 
andrew@4: 
andrew@4: 
andrew@4: /*
andrew@4:  double TimeWarp::getEnergyOfFrame(){
andrew@4:  
andrew@4:  
andrew@4:  float totalEnergyInFrame = 0;
andrew@4:  
andrew@4:  for (int i = 0;i<FRAMESIZE;i++){
andrew@4:  
andrew@4:  totalEnergyInFrame += (frame[i] * frame[i]);
andrew@4:  
andrew@4:  }
andrew@4:  totalEnergyInFrame = sqrt(totalEnergyInFrame);
andrew@4:  
andrew@4:  return totalEnergyInFrame;
andrew@4:  }
andrew@4:  */
andrew@4: