XCorrArrayType calculateCrossCorrelation(std::vector<double>& data1,
std::vector<double>& data2, const int& maxdelay, const int& lag)
{
OPENSWATH_PRECONDITION(data1.size() != 0 && data1.size() == data2.size(), "Both data vectors need to have the same length");
XCorrArrayType result;
result.data.reserve( std::ceil((2*maxdelay + 1) / lag));
int datasize = boost::numeric_cast<int>(data1.size());
int i, j, delay;
for (delay = -maxdelay; delay <= maxdelay; delay = delay + lag)
{
double sxy = 0;
for (i = 0; i < datasize; ++i)
{
j = i + delay;
if (j < 0 || j >= datasize)
{
continue;
}
sxy += (data1[i]) * (data2[j]);
}
result.data.push_back(std::make_pair(delay, sxy));
}
return result;
}
/// integrate all masses in window
bool integrateWindow(const OpenSwath::SpectrumPtr spectrum, double mz_start,
double mz_end, double & mz, double & intensity, bool centroided)
{
//check precondtion
OPENSWATH_PRECONDITION( std::adjacent_find(spectrum->getMZArray()->data.begin(),
spectrum->getMZArray()->data.end(), std::greater<double>()) == spectrum->getMZArray()->data.end(),
"Precondition violated: m/z vector needs to be sorted!" )
intensity = 0;
if (!centroided)
{
// get the weighted average for noncentroided data.
// TODO this is not optimal if there are two peaks in this window (e.g. if the window is too large)
mz = 0;
intensity = 0;
std::vector<double>::const_iterator mz_arr_end = spectrum->getMZArray()->data.end();
std::vector<double>::const_iterator int_it = spectrum->getIntensityArray()->data.begin();
// this assumes that the spectra are sorted!
std::vector<double>::const_iterator mz_it = std::lower_bound(spectrum->getMZArray()->data.begin(),
spectrum->getMZArray()->data.end(), mz_start);
std::vector<double>::const_iterator mz_it_end = std::lower_bound(mz_it, mz_arr_end, mz_end);
// also advance intensity iterator now
std::iterator_traits< std::vector<double>::const_iterator >::difference_type iterator_pos = std::distance((std::vector<double>::const_iterator)spectrum->getMZArray()->data.begin(), mz_it);
std::advance(int_it, iterator_pos);
for (; mz_it != mz_it_end; ++mz_it, ++int_it)
{
intensity += (*int_it);
mz += (*int_it) * (*mz_it);
}
if (intensity > 0.)
{
mz /= intensity;
return true;
}
else
{
mz = -1;
intensity = 0;
return false;
}
}
else
{
// not implemented
throw "Not implemented";
}
}
double RootMeanSquareDeviation(double x[], double y[], int n)
{
OPENSWATH_PRECONDITION(n > 0, "Need at least one element");
double result = 0;
for (int i = 0; i < n; i++)
{
result += (x[i] - y[i]) * (x[i] - y[i]);
}
return std::sqrt(result / n);
}
double NormalizedManhattanDist(double x[], double y[], int n)
{
OPENSWATH_PRECONDITION(n > 0, "Need at least one element");
double delta_ratio_sum = 0;
normalize_sum(x, n);
normalize_sum(y, n);
for (int i = 0; i < n; i++)
{
delta_ratio_sum += std::fabs(x[i] - y[i]);
}
return delta_ratio_sum / n;
}
XCorrArrayType normalizedCrossCorrelation(std::vector<double>& data1,
std::vector<double>& data2, const int& maxdelay, const int& lag = 1)
{
OPENSWATH_PRECONDITION(data1.size() != 0 && data1.size() == data2.size(), "Both data vectors need to have the same length");
// normalize the data
standardize_data(data1);
standardize_data(data2);
XCorrArrayType result = calculateCrossCorrelation(data1, data2, maxdelay, lag);
for (XCorrArrayType::iterator it = result.begin(); it != result.end(); ++it)
{
it->second = it->second / data1.size();
}
return result;
}
XCorrArrayType::const_iterator xcorrArrayGetMaxPeak(const XCorrArrayType& array)
{
OPENSWATH_PRECONDITION(array.data.size() > 0, "Cannot get highest apex from empty array.");
XCorrArrayType::const_iterator max_it = array.begin();
double max = array.begin()->second;
for (XCorrArrayType::const_iterator it = array.begin(); it != array.end(); ++it)
{
if (it->second > max)
{
max = it->second;
max_it = it;
}
}
return max_it;
}
double SpectralAngle(double x[], double y[], int n)
{
OPENSWATH_PRECONDITION(n > 0, "Need at least one element");
double dotprod = 0;
double x_len = 0;
double y_len = 0;
for (int i = 0; i < n; i++)
{
dotprod += x[i] * y[i];
x_len += x[i] * x[i];
y_len += y[i] * y[i];
}
x_len = std::sqrt(x_len);
y_len = std::sqrt(y_len);
return std::acos(dotprod / (x_len * y_len));
}
void standardize_data(std::vector<double>& data)
{
OPENSWATH_PRECONDITION(data.size() > 0, "Need non-empty array.");
// subtract the mean and divide by the standard deviation
double mean = std::accumulate(data.begin(), data.end(), 0.0) / (double) data.size();
double sqsum = 0;
for (std::vector<double>::iterator it = data.begin(); it != data.end(); ++it)
{
sqsum += (*it - mean) * (*it - mean);
}
double std = sqrt(sqsum / data.size()); // standard deviation
for (std::size_t i = 0; i < data.size(); i++)
{
data[i] = (data[i] - mean) / std;
}
}
XCorrArrayType calcxcorr_legacy_mquest_(std::vector<double>& data1,
std::vector<double>& data2, bool normalize)
{
OPENSWATH_PRECONDITION(!data1.empty() && data1.size() == data2.size(), "Both data vectors need to have the same length");
int maxdelay = boost::numeric_cast<int>(data1.size());
int lag = 1;
double mean1 = std::accumulate(data1.begin(), data1.end(), 0.) / (double)data1.size();
double mean2 = std::accumulate(data2.begin(), data2.end(), 0.) / (double)data2.size();
double denominator = 1.0;
int datasize = boost::numeric_cast<int>(data1.size());
int i, j, delay;
// Normalized cross-correlation = subtract the mean and divide by the standard deviation
if (normalize)
{
double sqsum1 = 0;
double sqsum2 = 0;
for (std::vector<double>::iterator it = data1.begin(); it != data1.end(); ++it)
{
sqsum1 += (*it - mean1) * (*it - mean1);
}
for (std::vector<double>::iterator it = data2.begin(); it != data2.end(); ++it)
{
sqsum2 += (*it - mean2) * (*it - mean2);
}
// sigma_1 * sigma_2 * n
denominator = sqrt(sqsum1 * sqsum2);
}
XCorrArrayType result;
result.data.reserve( std::ceil((2*maxdelay + 1) / lag));
int cnt = 0;
for (delay = -maxdelay; delay <= maxdelay; delay = delay + lag, cnt++)
{
double sxy = 0;
for (i = 0; i < datasize; i++)
{
j = i + delay;
if (j < 0 || j >= datasize)
{
continue;
}
if (normalize)
{
sxy += (data1[i] - mean1) * (data2[j] - mean2);
}
else
{
sxy += (data1[i]) * (data2[j]);
}
}
if (denominator > 0)
{
result.data.push_back(std::make_pair(delay, sxy/denominator));
}
else
{
// e.g. if all datapoints are zero
result.data.push_back(std::make_pair(delay, 0));
}
}
return result;
}
