calcul.cpp

#include "stdafx.h"

#include "calcul.h"
#include <numeric>
#include <deque>
#include <bitset>
#include "cstruct.h"
#include "print.h"

using namespace std;

///Calculates distance between two vectors.
///@param[in] u element of the compared time series (n dimensional vector)
///@param[in] v element of the compared time series (n dimensional vector)
///@return Euclidean distance
double calcul::distance_dtw_euklid(vtr<double> const &u, vtr<double> const &v)
{
	double sum = 0;

	for (size_t i = 0; i < u.size(); i++)
	{		
		sum += pow(u[i] - v[i], 2);
	}

	return sum;
}

/////Calculates distance between time series elements.
/////@param[in] point time series elements for distance calculation
/////@return Euklidean distance
//double calcul::distance_dtw_euklid2(input_method const &series, int idxA, int idxB)
//{
//	double sum = 0;
//
//	for (size_t i = 0; i < series.A.size(); i++)
//	{
//		sum += pow(series.A[i][idxA] - series.B[i][idxB], 2);
//	}
//
//	return sum;
//}

///Calculates distance between two vectors.
///@param[in] u element of the compared time series (n dimensional vector)
///@param[in] v element of the compared time series (n dimensional vector)
///@return Euclidean mean distance
//double calcul::distance_dtw_euklid_mean(vtr<double> const &u, vtr<double> const &v)
//{
//	double sum = 0;
//	for (size_t i = 0; i < u.size(); i++)
//	{
//		double ratio = 0;
//
//		if (u[i] > v[i])
//			ratio += 1 - v[i] / u[i];
//		else if (v[i] > u[i])
//			sum += 1 - u[i] / v[i];
//
//		sum += std::abs(1 - u[i] / (v[i] + 0.00000001));	
//	}
//
//	return sum;
//}

///Calculates distance between two vectors.
///@param[in] u element of the compared time series (n dimensional vector)
///@param[in] v element of the compared time series (n dimensional vector)
///@return Manhattan distance
double calcul::distance_dtw_manhattan(vtr<double> const &u, vtr<double> const &v)
{
	double sum = 0;

	for (size_t i = 0; i < u.size(); i++)
	{
		sum += abs(u[i] - v[i]);
	}

	return sum;
}

/////Calculates distance between time series elements.
/////@param[in] point time series elements for distance calculation
/////@return Euklidean distance
//double calcul::distance_dtw_manhattan2(input_method const &series, int idxA, int idxB)
//{
//	double sum = 0;
//
//	for (size_t i = 0; i < series.A.size(); i++)
//	{
//		sum += abs(series.A[i][idxA] - series.B[i][idxB]);
//	}
//
//	return sum;
//}

///Calculates chroma distance between two 12d vectors (specific data music data format needed).
///@param[in] u element of the compared time series (12d vector)
///@param[in] v element of the compared time series (12d vector)
///@param[in] threshold used for filtering insignificant tones in the input vectors
///@return Euclidean distance
double calcul::distance_dtw_csiChroma(vtr<double> const &u, vtr<double> const &v, double threshold /*def value in header*/)
{
	vtr<int> u_filter(u.size());
	vtr<int> v_filter(v.size());

	//binary filtering
	for (size_t i = 0; i < u.size(); i++)
	{
		if (u[i] > threshold)
			u_filter[i] = 1;

		if (v[i] > threshold)
			v_filter[i] = 1;
	}

	auto getRoot = [&scale = cstruct::scaleChord](vtr<double> const &vec) {
		int idx = 0;
		int min = constant::MAX_int;
		for (int i = 0; i < (int)scale.size(); i++) {
			int sum = 0;
			for (size_t j = 0; j < vec.size(); j++)
				sum += (int)std::abs(vec[j] - scale[i][j]);			//max value == 1 -> pow 2 -> abs

			if (sum < min) {
				min = sum;
				idx = i;
			}
		}
		return idx;
	};

	//search minimal distance between filtered vectors and minor/major scale
	//for (int i = 0; i < (int)scaleChord.size(); i++)
	//{
	//	int sumU = 0;
	//	int sumV = 0;
	//	for (size_t j = 0; j < u.size(); j++)
	//	{
	//		sumU += std::abs(u_filter[j] - scaleChord[i][j]);
	//		sumV += std::abs(v_filter[j] - scaleChord[i][j]);
	//		//max value == 1 -> pow 2 -> abs
	//	}

	//	if (sumU < minU)
	//	{
	//		minU = sumU;
	//		idxU = i;
	//	}

	//	if (sumV < minV)
	//	{
	//		minV = sumV;
	//		idxV = i;
	//	}
	//}

	auto idxU = getRoot(u);
	auto idxV = getRoot(v);

	//calculate result (zero u/v if minimal scale vectors == 1)
	double result = 0;
	for (size_t i = 0; i < u.size(); i++)
	{
		double tmpU;
		if (cstruct::scaleChord[idxU][i] == 1)
			tmpU = 0;
		else
			tmpU = u[i];

		double tmpV;
		if (cstruct::scaleChord[idxV][i] == 1)
			tmpV = 0;
		else
			tmpV = v[i];

		//result += std::abs(tmpU - tmpV);
		result += std::pow(tmpU - tmpV, 2);
	}

	return result;
}

/////Calculates distance between time series elements.
/////@param[in] point time series elements for distance calculation
/////@return Euklidean distance
//double calcul::distance_dtw_csiChroma2(series)
//{
//	vtr<int> u_filter(point.p1.size());
//	vtr<int> v_filter(point.p2.size());
//
//	//binary filtering
//	for (size_t i = 0; i < point.p1.size(); i++)
//	{
//		if (point.p1[i] > point.threshold)
//			u_filter[i] = 1;
//
//		if (point.p2[i] > point.threshold)
//			v_filter[i] = 1;
//	}
//