ctkDICOMHostMainLogic::ctkDICOMHostMainLogic(ctkHostedAppPlaceholderWidget* placeHolder, ctkDICOMAppWidget* dicomAppWidget,
QWidget* placeHolderForControls) :
QObject(placeHolder),
PlaceHolderForHostedApp(placeHolder),
DicomAppWidget(dicomAppWidget),
PlaceHolderForControls(placeHolderForControls),
ValidSelection(false),
SendData(false)
{
this->Host = new ctkExampleDicomHost(PlaceHolderForHostedApp);
this->HostControls = new ctkExampleHostControlWidget(Host, PlaceHolderForControls);
Data = new ctkDicomAppHosting::AvailableData;
disconnect(this->Host,SIGNAL(startProgress()),this->Host,SLOT(onStartProgress()));
connect(this->Host,SIGNAL(appReady()),this,SLOT(onAppReady()), Qt::QueuedConnection);
connect(this->Host,SIGNAL(startProgress()),this,SLOT(publishSelectedData()), Qt::QueuedConnection);
connect(this->PlaceHolderForHostedApp,SIGNAL(resized()),this,SLOT(placeHolderResized()));
QTreeView * treeview = dicomAppWidget->findChild<QTreeView*>("TreeView");
QItemSelectionModel* selectionmodel = treeview->selectionModel();
connect(selectionmodel, SIGNAL(selectionChanged ( const QItemSelection &, const QItemSelection & )),
this, SLOT(onTreeSelectionChanged(const QItemSelection &, const QItemSelection &)));
connect(this->Host, SIGNAL(dataAvailable()), this, SLOT(onDataAvailable()));
connect( qApp, SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()) );
}
void MapAlignmentAlgorithmIdentification::alignPeptideIdentifications(
vector<vector<PeptideIdentification> > & maps,
vector<TransformationDescription> & transformations)
{
checkParameters_(maps.size());
startProgress(0, 3, "aligning peptide identifications");
if (reference_index_) // reference is one of the input files
{
SeqToList rt_data;
getRetentionTimes_(maps[reference_index_ - 1], rt_data);
computeMedians_(rt_data, reference_, true);
}
// one set of RT data for each input map, except reference:
vector<SeqToList> rt_data(maps.size() - bool(reference_index_));
for (Size i = 0, j = 0; i < maps.size(); ++i)
{
if (i == reference_index_ - 1)
continue; // skip reference map, if any
getRetentionTimes_(maps[i], rt_data[j++]);
}
setProgress(1);
computeTransformations_(rt_data, transformations, true);
setProgress(2);
// transformPeptideIdentifications(maps, transformations);
setProgress(3);
endProgress();
}
/**
* @brief Video::convertToEvent
* @param path
* @return
*/
EventPtr Video::convertToEvent(std::string path){
cv::Mat shot;
FramePtr frame;
EventPtr event;
unsigned int j=0;
int framecount=0;
double tmpPos = getFramePos();
setFramePos(0);
emit startProgress(0, (uint) getLengthFrames());
while(getNextFrame(shot)){
emit progressChanged(j);
if (event.isNull()){
event = EventPtr(new Event(this));
}
// create new frame
frame = FramePtr(new Frame(this, shot, path));
// add frame to event
event->addFrame(frame);
framecount ++;
j++;
}
setFramePos(tmpPos);
return event;
}
void ProgressBar::restartProgress()
{
VC3 tmp = this->progressPosition;
float tmp2 = this->progressAngle;
stopProgress();
startProgress(this->unit, tmp, tmp2);
}
void ZProgressManager::connectSignalSlot()
{
connect(this, SIGNAL(progressStarted()), this, SLOT(startProgress()));
connect(this, SIGNAL(progressEnded()), this, SLOT(endProgress()));
connect(this, SIGNAL(progressReset()), this, SLOT(resetProgress()));
connect(this, SIGNAL(progressStarted(double)),
this, SLOT(startProgress(double)));
connect(this, SIGNAL(progressEnded(double)),
this, SLOT(endProgress(double)));
connect(this, SIGNAL(progressAdvanced(double)),
this, SLOT(advanceProgress(double)));
}
void ZSwcTreeBatchMatcher::process()
{
m_isFinished = true;
if (!m_isStarted) {
startProgress();
foreach (ZFlyEmNeuronMatchThread *thread, m_threadArray) {
ZFlyEmNeuron *neuron = dequeueNeuron();
if (neuron != NULL) {
thread->setTarget(neuron);
thread->start();
m_isFinished = false;
}
}
void OGL_StartProgress(int total_progress)
{
startProgress ( total_progress );
/*
ogl_progress = 0;
total_ogl_progress = total_progress;
if (!OGL_LoadScreen::instance()->Start()) {
OGL_ClearScreen();
open_progress_dialog(_loading, true);
}
show_ogl_progress = true;
last_update_tick = SDL_GetTicks();
*/
}
//----------------------------------------------------------------------------
ctkExampleDicomHost::ctkExampleDicomHost(ctkHostedAppPlaceholderWidget* placeholderWidget, int hostPort, int appPort) :
ctkDicomAbstractHost(hostPort, appPort),
PlaceholderWidget(placeholderWidget),
exitingApplication(false)
{
connect(this,SIGNAL(appReady()),SLOT(onAppReady()));
connect(this,SIGNAL(startProgress()),this,SLOT(onStartProgress()));
connect(this,SIGNAL(releaseAvailableResources()),this,SLOT(onReleaseAvailableResources()));
connect(this,SIGNAL(resumed()),this,SLOT(onResumed()));
connect(this,SIGNAL(completed()),this,SLOT(onCompleted()));
connect(this,SIGNAL(suspended()),this,SLOT(onSuspended()));
connect(this,SIGNAL(canceled()),this,SLOT(onCanceled()));
connect(this,SIGNAL(exited()),this,SLOT(onExited()));
}
void ZMultiTaskManager::start()
{
if (m_taskArray.empty()) {
return;
}
#ifdef _DEBUG_
std::cout << "Start with " << getThreadPool()->maxThreadCount() << " threads."
<< std::endl;
#endif
startProgress();
prepare();
foreach (ZTask *task, m_taskArray) {
#ifdef _DEBUG_2
std::cout << "Start task" << std::endl;
#endif
getThreadPool()->start(task);
}
//----------------------------------------------------------------------------
ctkExampleDicomAppLogic::ctkExampleDicomAppLogic():
ctkDicomAbstractApp(ctkExampleDicomAppPlugin::getPluginContext()), AppWidget(0)
{
connect(this, SIGNAL(startProgress()), this, SLOT(onStartProgress()), Qt::QueuedConnection);
connect(this, SIGNAL(resumeProgress()), this, SLOT(onResumeProgress()), Qt::QueuedConnection);
connect(this, SIGNAL(suspendProgress()), this, SLOT(onSuspendProgress()), Qt::QueuedConnection);
connect(this, SIGNAL(cancelProgress()), this, SLOT(onCancelProgress()), Qt::QueuedConnection);
connect(this, SIGNAL(exitHostedApp()), this, SLOT(onExitHostedApp()), Qt::QueuedConnection);
connect(this, SIGNAL(dataAvailable()), this, SLOT(onDataAvailable()));
//notify Host we are ready.
try {
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::IDLE);
}
catch(...)
{
qDebug() << "ctkDicomAbstractApp: Could not getHostInterface()";
}
}
void InstallScreen::initDBusServices()
{
m_ociHelper = new org::opensuse::OCIHelper("org.opensuse.OCIHelper", "/", QDBusConnection::systemBus(), this);
if ( !m_ociHelper->isValid() ) {
qFatal( "Oops! Cannot connect to the service org.opensuse.OCIHelper" );
exit( 1 );
}
m_mediaCallbacks = new org::opensuse::MediaCallbacks("org.opensuse.MediaCallbacks", "/Media", QDBusConnection::systemBus(), this);
if ( !m_mediaCallbacks->isValid() ) {
qFatal( "Oops! Cannot connect to the service org.opensuse.MediaCallbacks" );
exit( 1 );
}
qDebug() << " DBus proxies initialized";
// signals and slots
connect( m_mediaCallbacks, SIGNAL( startProgress( QString ) ), this, SLOT( newProgressInAction( QString ) ) );
connect( m_mediaCallbacks, SIGNAL( startResolvable( QString ) ), this, SLOT( newResolvableInAction( QString ) ) );
connect( m_mediaCallbacks, SIGNAL( finishProgress( QString, bool ) ), this, SLOT( updateCurrentProgressStatusUponCompletion( QString, bool ) ) );
connect( m_mediaCallbacks, SIGNAL( finishResolvable( QString, bool ) ), this, SLOT( updateCurrentResolvableStatusUponCompletion( QString, bool ) ) );
connect( m_mediaCallbacks, SIGNAL( progress( int ) ), m_progressBar, SLOT( setValue( int ) ) ); // update progress
}
void CompleteLinkage::operator()(DistanceMatrix<float> & original_distance, std::vector<BinaryTreeNode> & cluster_tree, const float threshold /*=1*/) const
{
// attention: clustering process is done by clustering the indices
// pointing to elements in inputvector and distances in inputmatrix
// input MUST have >= 2 elements!
if (original_distance.dimensionsize() < 2)
{
throw ClusterFunctor::InsufficientInput(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Distance matrix to start from only contains one element");
}
std::vector<std::set<Size> > clusters(original_distance.dimensionsize());
for (Size i = 0; i < original_distance.dimensionsize(); ++i)
{
clusters[i].insert(i);
}
cluster_tree.clear();
cluster_tree.reserve(original_distance.dimensionsize() - 1);
// Initial minimum-distance pair
original_distance.updateMinElement();
std::pair<Size, Size> min = original_distance.getMinElementCoordinates();
Size overall_cluster_steps(original_distance.dimensionsize());
startProgress(0, original_distance.dimensionsize(), "clustering data");
while (original_distance(min.first, min.second) < threshold)
{
//grow the tree
cluster_tree.push_back(BinaryTreeNode(*(clusters[min.second].begin()), *(clusters[min.first].begin()), original_distance(min.first, min.second)));
if (cluster_tree.back().left_child > cluster_tree.back().right_child)
{
std::swap(cluster_tree.back().left_child, cluster_tree.back().right_child);
}
if (original_distance.dimensionsize() > 2)
{
//pick minimum-distance pair i,j and merge them
//pushback elements of second to first (and then erase second)
clusters[min.second].insert(clusters[min.first].begin(), clusters[min.first].end());
// erase first one
clusters.erase(clusters.begin() + min.first);
//update original_distance matrix
//complete linkage: new distance between clusters is the minimum distance between elements of each cluster
//lance-williams update for d((i,j),k): 0.5* d(i,k) + 0.5* d(j,k) + 0.5* |d(i,k)-d(j,k)|
for (Size k = 0; k < min.second; ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(min.second, k, (0.5f * dik + 0.5f * djk + 0.5f * std::fabs(dik - djk)));
}
for (Size k = min.second + 1; k < original_distance.dimensionsize(); ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(k, min.second, (0.5f * dik + 0.5f * djk + 0.5f * std::fabs(dik - djk)));
}
//reduce
original_distance.reduce(min.first);
//update minimum-distance pair
original_distance.updateMinElement();
//get new min-pair
min = original_distance.getMinElementCoordinates();
}
else
{
break;
}
setProgress(overall_cluster_steps - original_distance.dimensionsize());
//repeat until only two cluster remains or threshold exceeded, last step skips matrix operations
}
//fill tree with dummy nodes
Size sad(*clusters.front().begin());
for (Size i = 1; i < clusters.size() && (cluster_tree.size() < cluster_tree.capacity()); ++i)
{
cluster_tree.push_back(BinaryTreeNode(sad, *clusters[i].begin(), -1.0));
}
//~ while(cluster_tree.size() < cluster_tree.capacity())
//~ {
//~ cluster_tree.push_back(BinaryTreeNode(0,1,-1.0));
//~ }
endProgress();
}
/**
* @brief Automatically splits the video into several events provided the
* given parameters.
* @param threshold
* @param maxcount
* @param mincount
* @param history
* @param varThreshold
* @param bShadowDetection
* @param path
* @return
*/
std::deque<EventPtr> Video::autoDetectEvents(double threshold,
double maxcount,
double mincount,
int history,
int varThreshold,
bool bShadowDetection,
std::string path){
cv::Mat shot;
FramePtr frame;
SnapshotPtr snap;
EventPtr event;
std::deque<EventPtr> events;
unsigned int j=0;
int emptycount=0;
int framecount=0;
int value;
int absoluteThreshold = threshold/100*resolution.width*resolution.height;
int i;
// Initialization of background subtraction
bgSubInit(history, varThreshold, bShadowDetection);
setFramePos(0);
emit startProgress(0, (uint) getLengthFrames());
while(getNextFrame(shot)){
QCoreApplication::processEvents();
if (toCancel){
events.clear();
canceled();
return events;
}
bg->NewFrame(shot);
bg->Denoise();
emit progressChanged(j);
value = cv::countNonZero(bg->Foreground());
// Detected change
if ( value > absoluteThreshold ){
if (event.isNull()){
event = EventPtr(new Event(this));
}
// create new frame
frame = FramePtr(new Frame(this, shot, path));
snap = SnapshotPtr(new Snapshot(frame, bg->Foreground(), path));
// add frame to event
event->addFrame(frame);
event->addSnapshot(snap);
framecount ++;
emptycount = 0;
}
// Did not detect change
else if (!event.isNull()){
emptycount ++;
// create new frame
frame = FramePtr(new Frame(this, shot, path));
snap = SnapshotPtr(new Snapshot(frame, bg->Foreground(), path));
// add frame to event
event->addFrame(frame);
event->addSnapshot(snap);
framecount ++;
if(emptycount > maxcount){
if (framecount - emptycount > mincount){
// remove extra frames with no movement
for (i = 0; i < maxcount; i++){
event->remLastFrame();
event->remLastSnapshot();
}
events.push_back(event);
}
event.clear();
emptycount = 0;
framecount = 0;
}
}
j++;
}
// Check if Video ended in the middle of an Event.
if (!event.isNull()){
if (framecount > mincount){
events.push_back(event);
} else {
event.clear();
}
}
return events;
}
/**
* @brief Applies the peak-picking algorithm to a map (MSExperiment). This
* method picks peaks for each scan in the map consecutively. The resulting
* picked peaks are written to the output map.
*
* @param input input map in profile mode
* @param output output map with picked peaks
* @param boundaries_spec boundaries of the picked peaks in spectra
* @param boundaries_chrom boundaries of the picked peaks in chromatograms
* @param check_spectrum_type if set, checks spectrum type and throws an exception if a centroided spectrum is passed
*/
void PeakPickerHiRes::pickExperiment(const PeakMap& input, PeakMap& output,
std::vector<std::vector<PeakBoundary> >& boundaries_spec,
std::vector<std::vector<PeakBoundary> >& boundaries_chrom,
const bool check_spectrum_type) const
{
// make sure that output is clear
output.clear(true);
// copy experimental settings
static_cast<ExperimentalSettings &>(output) = input;
// resize output with respect to input
output.resize(input.size());
Size progress = 0;
startProgress(0, input.size() + input.getChromatograms().size(), "picking peaks");
if (input.getNrSpectra() > 0)
{
for (Size scan_idx = 0; scan_idx != input.size(); ++scan_idx)
{
if (ms_levels_.empty()) // auto mode
{
SpectrumSettings::SpectrumType spectrum_type = input[scan_idx].getType();
if (spectrum_type == SpectrumSettings::CENTROID)
{
output[scan_idx] = input[scan_idx];
}
else
{
std::vector<PeakBoundary> boundaries_s; // peak boundaries of a single spectrum
pick(input[scan_idx], output[scan_idx], boundaries_s);
boundaries_spec.push_back(boundaries_s);
}
}
else if (!ListUtils::contains(ms_levels_, input[scan_idx].getMSLevel())) // manual mode
{
output[scan_idx] = input[scan_idx];
}
else
{
std::vector<PeakBoundary> boundaries_s; // peak boundaries of a single spectrum
// determine type of spectral data (profile or centroided)
SpectrumSettings::SpectrumType spectrum_type = input[scan_idx].getType();
if (spectrum_type == SpectrumSettings::CENTROID && check_spectrum_type)
{
throw OpenMS::Exception::IllegalArgument(__FILE__, __LINE__, __FUNCTION__, "Error: Centroided data provided but profile spectra expected.");
}
pick(input[scan_idx], output[scan_idx], boundaries_s);
boundaries_spec.push_back(boundaries_s);
}
setProgress(++progress);
}
}
for (Size i = 0; i < input.getChromatograms().size(); ++i)
{
MSChromatogram chromatogram;
std::vector<PeakBoundary> boundaries_c; // peak boundaries of a single chromatogram
pick(input.getChromatograms()[i], chromatogram, boundaries_c);
output.addChromatogram(chromatogram);
boundaries_chrom.push_back(boundaries_c);
setProgress(++progress);
}
endProgress();
return;
}
vector<MultiplexFilterResult> MultiplexFilteringProfile::filter()
{
// progress logger
unsigned progress = 0;
startProgress(0, patterns_.size() * exp_profile_.size(), "filtering LC-MS data");
// list of filter results for each peak pattern
vector<MultiplexFilterResult> filter_results;
// loop over patterns
for (unsigned pattern = 0; pattern < patterns_.size(); ++pattern)
{
// data structure storing peaks which pass all filters
MultiplexFilterResult result;
// iterate over spectra
PeakMap::Iterator it_rt_profile;
PeakMap::ConstIterator it_rt_picked;
vector<vector<PeakPickerHiRes::PeakBoundary> >::const_iterator it_rt_boundaries;
for (it_rt_profile = exp_profile_.begin(), it_rt_picked = exp_picked_.begin(), it_rt_boundaries = boundaries_.begin();
it_rt_profile < exp_profile_.end() && it_rt_picked < exp_picked_.end() && it_rt_boundaries < boundaries_.end();
++it_rt_profile, ++it_rt_picked, ++it_rt_boundaries)
{
// skip empty spectra
if ((*it_rt_profile).size() == 0 || (*it_rt_picked).size() == 0 || (*it_rt_boundaries).size() == 0)
{
continue;
}
if ((*it_rt_picked).size() != (*it_rt_boundaries).size())
{
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Number of peaks and number of peak boundaries differ.");
}
setProgress(++progress);
int spectrum = it_rt_profile - exp_profile_.begin(); // index of the spectrum in exp_profile_, exp_picked_ and boundaries_
double rt_picked = it_rt_picked->getRT();
// spline fit profile data
SplineSpectrum spline(*it_rt_profile);
SplineSpectrum::Navigator nav = spline.getNavigator();
// vectors of peak details
vector<double> peak_position;
vector<double> peak_min;
vector<double> peak_max;
vector<double> peak_intensity;
MSSpectrum<Peak1D>::ConstIterator it_mz;
vector<PeakPickerHiRes::PeakBoundary>::const_iterator it_mz_boundary;
for (it_mz = it_rt_picked->begin(), it_mz_boundary = it_rt_boundaries->begin();
it_mz < it_rt_picked->end() && it_mz_boundary < it_rt_boundaries->end();
++it_mz, ++it_mz_boundary)
{
peak_position.push_back(it_mz->getMZ());
peak_min.push_back((*it_mz_boundary).mz_min);
peak_max.push_back((*it_mz_boundary).mz_max);
peak_intensity.push_back(it_mz->getIntensity());
}
// iterate over peaks in spectrum (mz)
for (unsigned peak = 0; peak < peak_position.size(); ++peak)
{
/**
* Filter (1): m/z position and blacklist filter
* Are there non-black peaks with the expected relative m/z shifts?
*/
vector<double> mz_shifts_actual; // actual m/z shifts (differ slightly from expected m/z shifts)
vector<int> mz_shifts_actual_indices; // peak indices in the spectrum corresponding to the actual m/z shifts
mz_shifts_actual.reserve(patterns_[pattern].getMZShiftCount());
mz_shifts_actual_indices.reserve(patterns_[pattern].getMZShiftCount());
int peaks_found_in_all_peptides = positionsAndBlacklistFilter_(patterns_[pattern], spectrum, peak_position, peak, mz_shifts_actual, mz_shifts_actual_indices);
if (peaks_found_in_all_peptides < peaks_per_peptide_min_)
{
continue;
}
/**
* Filter (2): blunt intensity filter
* Are the mono-isotopic peak intensities of all peptides above the cutoff?
*/
bool bluntVeto = monoIsotopicPeakIntensityFilter_(patterns_[pattern], spectrum, mz_shifts_actual_indices);
if (bluntVeto)
{
continue;
}
// Arrangement of peaks looks promising. Now scan through the spline fitted data.
vector<MultiplexFilterResultRaw> results_raw; // raw data points of this peak that will pass the remaining filters
bool blacklisted = false; // Has this peak already been blacklisted?
for (double mz = peak_min[peak]; mz < peak_max[peak]; mz = nav.getNextMz(mz))
{
/**
* Filter (3): non-local intensity filter
* Are the spline interpolated intensities at m/z above the threshold?
*/
vector<double> intensities_actual; // spline interpolated intensities @ m/z + actual m/z shift
int peaks_found_in_all_peptides_spline = nonLocalIntensityFilter_(patterns_[pattern], mz_shifts_actual, mz_shifts_actual_indices, nav, intensities_actual, peaks_found_in_all_peptides, mz);
if (peaks_found_in_all_peptides_spline < peaks_per_peptide_min_)
{
continue;
}
/**
* Filter (4): zeroth peak filter
* There should not be a significant peak to the left of the mono-isotopic
* (i.e. first) peak.
*/
bool zero_peak = zerothPeakFilter_(patterns_[pattern], intensities_actual);
if (zero_peak)
{
continue;
}
/**
* Filter (5): peptide similarity filter
* How similar are the isotope patterns of the peptides?
*/
bool peptide_similarity = peptideSimilarityFilter_(patterns_[pattern], intensities_actual, peaks_found_in_all_peptides_spline);
if (!peptide_similarity)
{
continue;
}
/**
* Filter (6): averagine similarity filter
* Does each individual isotope pattern resemble a peptide?
*/
bool averagine_similarity = averagineSimilarityFilter_(patterns_[pattern], intensities_actual, peaks_found_in_all_peptides_spline, mz);
if (!averagine_similarity)
{
continue;
}
/**
* All filters passed.
*/
// add raw data point to list that passed all filters
MultiplexFilterResultRaw result_raw(mz, mz_shifts_actual, intensities_actual);
results_raw.push_back(result_raw);
// blacklist peaks in the current spectrum and the two neighbouring ones
if (!blacklisted)
{
blacklistPeaks_(patterns_[pattern], spectrum, mz_shifts_actual_indices, peaks_found_in_all_peptides_spline);
blacklisted = true;
}
}
// add the peak with its corresponding raw data to the result
if (results_raw.size() > 2)
{
// Scanning over the profile of the peak, we want at least three raw data points to pass all filters.
vector<double> intensities_actual;
for (unsigned i = 0; i < mz_shifts_actual_indices.size(); ++i)
{
int index = mz_shifts_actual_indices[i];
if (index == -1)
{
// no peak found
intensities_actual.push_back(std::numeric_limits<double>::quiet_NaN());
}
else
{
intensities_actual.push_back(peak_intensity[mz_shifts_actual_indices[i]]);
}
}
result.addFilterResultPeak(peak_position[peak], rt_picked, mz_shifts_actual, intensities_actual, results_raw);
}
}
}
// add results of this pattern to list
filter_results.push_back(result);
}
endProgress();
return filter_results;
}
void CProgressBar::startProgressFromTo(int nFromValue, int nToValue, float fDuration)
{
changeValueAndExecuteEvent(nFromValue, true);
startProgress(nToValue, fDuration);
}
void TOFCalibration::calculateCalibCoeffs_(MSExperiment<> & calib_spectra)
{
// flight times are needed later
calib_peaks_ft_ = calib_spectra;
// convert flight times of peaks into m/z values
applyTOFConversion_(calib_spectra);
std::vector<std::vector<unsigned int> > monoiso_peaks;
getMonoisotopicPeaks_(calib_spectra, monoiso_peaks);
startProgress(0, calib_spectra.size(), "quadratic fitting of calibrant spectra");
// do the quadratic fitting for each calibration spectra separately
for (unsigned int spec = 0; spec < calib_spectra.size(); ++spec)
{
std::vector<unsigned int> monoiso_peaks_scan;
std::vector<double> exp_masses;
// match the m/z-values to the expected masses
matchMasses_(calib_spectra, monoiso_peaks, monoiso_peaks_scan, exp_masses, spec);
// the actual quadratic fitting part
Size n = exp_masses.size();
if (n < 3)
{
continue;
}
// matrix containing the observations
std::vector<double> x;
// vector containing the expected masses
std::vector<double> y;
for (Size i = 0; i < n; i++)
{
// get the flight time
double xi = ((calib_peaks_ft_.begin() + spec)->begin() + monoiso_peaks_scan[i])->getMZ();
x.push_back(xi);
y.push_back(exp_masses[i]);
}
Math::QuadraticRegression qr;
qr.computeRegression(x.begin(), x.end(), y.begin());
#ifdef DEBUG_CALIBRATION
std::cout << "chi^2: " << qr.getChiSquared() << std::endl;//DEBUG
std::cout << "a: " << qr.getA() << "b: " << qr.getB()
<< "c: " << qr.getC() << std::endl;//DEBUG
#endif
// store the coefficients
coeff_quad_fit_.push_back(qr.getA());
coeff_quad_fit_.push_back(qr.getB());
coeff_quad_fit_.push_back(qr.getC());
// determine the errors in ppm
for (Size p = 0; p < n; ++p)
{
#ifdef DEBUG_CALIBRATION
std::cout << exp_masses[p]
<< "\t" << mQ_(calib_peaks_ft_[spec][monoiso_peaks_scan[p]].getMZ(), spec) - exp_masses[p] << std::endl;
#endif
errors_[exp_masses[p]].push_back((mQ_(calib_peaks_ft_[spec][monoiso_peaks_scan[p]].getMZ(), spec) - exp_masses[p]));
}
setProgress(spec);
}
endProgress();
if (coeff_quad_fit_.empty())
{
String mess = String("Data can't be calibrated, not enough reference masses found: ") + coeff_quad_fit_.size() / 3;
throw Exception::UnableToCalibrate(__FILE__, __LINE__, __PRETTY_FUNCTION__, "UnableToCalibrate", mess.c_str());
}
averageErrors_();
averageCoefficients_();
}
void TransitionPQPReader::writePQPOutput_(const char* filename, OpenMS::TargetedExperiment& targeted_exp)
{
sqlite3 *db;
char *zErrMsg = 0;
int rc;
// delete file if present
remove(filename);
// Open database
rc = sqlite3_open(filename, &db);
if ( rc )
{
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
}
// Create SQL structure
const char* create_sql =
// protein table
// OpenSWATH proteomics workflows
"CREATE TABLE PROTEIN(" \
"ID INT PRIMARY KEY NOT NULL," \
"PROTEIN_ACCESSION TEXT NOT NULL," \
"DECOY INT NULL);" \
// peptide_protein_mapping table
// OpenSWATH proteomics workflows
"CREATE TABLE PEPTIDE_PROTEIN_MAPPING(" \
"PEPTIDE_ID INT NOT NULL," \
"PROTEIN_ID INT NOT NULL);" \
// peptide table
// OpenSWATH proteomics workflows
"CREATE TABLE PEPTIDE(" \
"ID INT PRIMARY KEY NOT NULL," \
"UNMODIFIED_SEQUENCE TEXT NOT NULL," \
"MODIFIED_SEQUENCE TEXT NOT NULL," \
"DECOY INT NOT NULL);" \
// precursor_peptide_mapping table
// OpenSWATH proteomics workflows
"CREATE TABLE PRECURSOR_PEPTIDE_MAPPING(" \
"PRECURSOR_ID INT NOT NULL," \
"PEPTIDE_ID INT NOT NULL);" \
// compound table
// OpenSWATH metabolomics workflows
"CREATE TABLE COMPOUND(" \
"ID INT PRIMARY KEY NOT NULL," \
"COMPOUND_NAME TEXT NOT NULL," \
"SUM_FORMULA TEXT NOT NULL," \
"SMILES TEXT NOT NULL," \
"DECOY INT NOT NULL);" \
// precursor_compound_mapping table
// OpenSWATH metabolomics workflows
"CREATE TABLE PRECURSOR_COMPOUND_MAPPING(" \
"PRECURSOR_ID INT NOT NULL," \
"COMPOUND_ID INT NOT NULL);" \
// precursor table
"CREATE TABLE PRECURSOR(" \
"ID INT PRIMARY KEY NOT NULL," \
"TRAML_ID TEXT NULL," \
"GROUP_LABEL TEXT NULL," \
"PRECURSOR_MZ REAL NOT NULL," \
"CHARGE INT NULL," \
"LIBRARY_INTENSITY REAL NULL," \
"LIBRARY_RT REAL NULL," \
"DECOY INT NOT NULL);" \
// transition_precursor_mapping table
"CREATE TABLE TRANSITION_PRECURSOR_MAPPING(" \
"TRANSITION_ID INT NOT NULL," \
"PRECURSOR_ID INT NOT NULL);" \
// transition_peptide_mapping table
// IPF proteomics workflows
"CREATE TABLE TRANSITION_PEPTIDE_MAPPING(" \
"TRANSITION_ID INT NOT NULL," \
"PEPTIDE_ID INT NOT NULL);" \
// transition table
"CREATE TABLE TRANSITION(" \
"ID INT PRIMARY KEY NOT NULL," \
"TRAML_ID TEXT NULL," \
"PRODUCT_MZ REAL NOT NULL," \
"CHARGE INT NULL," \
"TYPE CHAR(1) NULL," \
"ORDINAL INT NULL," \
"DETECTING INT NOT NULL," \
"IDENTIFYING INT NOT NULL," \
"QUANTIFYING INT NOT NULL," \
"LIBRARY_INTENSITY REAL NULL," \
"DECOY INT NOT NULL);";
// Execute SQL create statement
rc = sqlite3_exec(db, create_sql, callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Prepare insert statements
// Index maps
std::vector<std::string> group_set, peptide_set, compound_set, protein_set;
std::map<int,double> precursor_mz_map;
std::map<int,bool> precursor_decoy_map;
std::stringstream insert_transition_sql, insert_transition_peptide_mapping_sql, insert_transition_precursor_mapping_sql;
insert_transition_sql.precision(11);
// OpenSWATH: Loop through TargetedExperiment to generate index maps for peptides
Size progress = 0;
startProgress(0, targeted_exp.getPeptides().size(), "Convert peptides");
for (Size i = 0; i < targeted_exp.getPeptides().size(); i++)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Peptide peptide = targeted_exp.getPeptides()[i];
std::string peptide_sequence = TargetedExperimentHelper::getAASequence(peptide).toString();
peptide_set.push_back(peptide_sequence);
group_set.push_back(peptide.id);
}
endProgress();
// OpenSWATH: Loop through TargetedExperiment to generate index maps for compounds
progress = 0;
startProgress(0, targeted_exp.getCompounds().size(), "Convert compounds");
for (Size i = 0; i < targeted_exp.getCompounds().size(); i++)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Compound compound = targeted_exp.getCompounds()[i];
compound_set.push_back(compound.id);
group_set.push_back(compound.id);
}
endProgress();
// OpenSWATH: Group set must be unique
boost::erase(group_set, boost::unique<boost::return_found_end>(boost::sort(group_set)));
// IPF: Loop through all transitions and generate peptidoform data structures
progress = 0;
std::vector<TransitionPQPReader::TSVTransition > transitions;
startProgress(0, targeted_exp.getTransitions().size(), "Convert peptidoforms");
for (Size i = 0; i < targeted_exp.getTransitions().size(); i++)
{
setProgress(progress++);
TransitionPQPReader::TSVTransition transition = convertTransition_(&targeted_exp.getTransitions()[i], targeted_exp);
transitions.push_back(transition);
std::copy( transition.peptidoforms.begin(), transition.peptidoforms.end(), std::inserter( peptide_set, peptide_set.end() ) );
int group_set_index = std::distance(group_set.begin(),std::find(group_set.begin(), group_set.end(), transition.group_id));
if (precursor_mz_map.find(group_set_index) == precursor_mz_map.end())
{
precursor_mz_map[group_set_index] = transition.precursor;
}
if (precursor_decoy_map.find(group_set_index) == precursor_decoy_map.end())
{
if (transition.detecting_transition == 1)
{
precursor_decoy_map[group_set_index] = transition.decoy;
}
}
}
endProgress();
// OpenSWATH: Peptide and compound sets must be unique
boost::erase(peptide_set, boost::unique<boost::return_found_end>(boost::sort(peptide_set)));
boost::erase(compound_set, boost::unique<boost::return_found_end>(boost::sort(compound_set)));
// OpenSWATH: Prepare transition inserts
progress = 0;
startProgress(0, transitions.size(), String("Prepare ") + transitions.size() + " transitions and mapping");
for (Size i = 0; i < transitions.size(); i++)
{
setProgress(progress++);
TransitionPQPReader::TSVTransition transition = transitions[i];
// IPF: Generate transition-peptide mapping tables (one identification transition can map to multiple peptidoforms)
for (Size j = 0; j < transition.peptidoforms.size(); j++)
{
insert_transition_peptide_mapping_sql << "INSERT INTO TRANSITION_PEPTIDE_MAPPING (TRANSITION_ID, PEPTIDE_ID) VALUES (" << i << "," << std::distance(peptide_set.begin(),std::find(peptide_set.begin(), peptide_set.end(), transition.peptidoforms[j])) << "); ";
}
// OpenSWATH: Associate transitions with their precursors
insert_transition_precursor_mapping_sql << "INSERT INTO TRANSITION_PRECURSOR_MAPPING (TRANSITION_ID, PRECURSOR_ID) VALUES (" << i << "," << std::distance(group_set.begin(), std::find(group_set.begin(), group_set.end(),transition.group_id)) << "); ";
std::string transition_charge = "NULL"; // workaround for compounds with missing charge
if (transition.fragment_charge != "NA")
{
transition_charge = transition.fragment_charge;
}
// OpenSWATH: Insert transition data
insert_transition_sql << "INSERT INTO TRANSITION (ID, TRAML_ID, PRODUCT_MZ, CHARGE, TYPE, ORDINAL, DETECTING, IDENTIFYING, QUANTIFYING, LIBRARY_INTENSITY, DECOY) VALUES (" << i << ",'" << transition.transition_name << "'," << transition.product << "," << transition_charge << ",'" << transition.fragment_type<< "'," << transition.fragment_nr << "," << transition.detecting_transition << "," << transition.identifying_transition << "," << transition.quantifying_transition << "," << transition.library_intensity << "," << transition.decoy << "); ";
}
endProgress();
// OpenSWATH: Prepare protein inserts
progress = 0;
startProgress(0, targeted_exp.getProteins().size(), "Prepare protein mapping");
for (Size i = 0; i < targeted_exp.getProteins().size(); i++)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Protein protein = targeted_exp.getProteins()[i];
protein_set.push_back(protein.id);
}
endProgress();
boost::erase(protein_set, boost::unique<boost::return_found_end>(boost::sort(protein_set)));
std::stringstream insert_precursor_sql, insert_precursor_peptide_mapping, insert_precursor_compound_mapping;
insert_precursor_sql.precision(11);
std::vector<std::pair<int, int> > peptide_protein_map;
// OpenSWATH: Prepare peptide precursor inserts
progress = 0;
startProgress(0, targeted_exp.getPeptides().size(), "Prepare peptide precursors and mapping");
for (Size i = 0; i < targeted_exp.getPeptides().size(); i++)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Peptide peptide = targeted_exp.getPeptides()[i];
std::string peptide_sequence = TargetedExperimentHelper::getAASequence(peptide).toString();
int group_set_index = std::distance(group_set.begin(),std::find(group_set.begin(), group_set.end(), peptide.id));
int peptide_set_index = std::distance(peptide_set.begin(), std::find(peptide_set.begin(), peptide_set.end(), peptide_sequence));
for (std::vector<String>::iterator it = peptide.protein_refs.begin(); it != peptide.protein_refs.end(); ++it)
{
int protein_set_index = std::distance(protein_set.begin(),std::find(protein_set.begin(), protein_set.end(), *it));
peptide_protein_map.push_back(std::make_pair(peptide_set_index,protein_set_index));
}
insert_precursor_sql << "INSERT INTO PRECURSOR (ID, TRAML_ID, GROUP_LABEL, PRECURSOR_MZ, CHARGE, LIBRARY_INTENSITY, LIBRARY_RT, DECOY) VALUES (" << group_set_index << ",'" << peptide.id << "','" << peptide.getPeptideGroupLabel() << "'," << precursor_mz_map[group_set_index] << "," << peptide.getChargeState() << ",NULL," << peptide.getRetentionTime() << "," << precursor_decoy_map[group_set_index] << "); ";
insert_precursor_peptide_mapping << "INSERT INTO PRECURSOR_PEPTIDE_MAPPING (PRECURSOR_ID, PEPTIDE_ID) VALUES (" << group_set_index << "," << peptide_set_index << "); ";
}
endProgress();
// OpenSWATH: Prepare compound precursor inserts
progress = 0;
startProgress(0, targeted_exp.getCompounds().size(), "Prepare compound precursors and mapping");
for (Size i = 0; i < targeted_exp.getCompounds().size(); i++)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Compound compound = targeted_exp.getCompounds()[i];
int group_set_index = std::distance(group_set.begin(),std::find(group_set.begin(), group_set.end(), compound.id));
int compound_set_index = std::distance(compound_set.begin(), std::find(compound_set.begin(), compound_set.end(), compound.id));
std::string compound_charge = "NULL"; // workaround for compounds with missing charge
if (compound.hasCharge())
{
compound_charge = String(compound.getChargeState());
}
insert_precursor_sql << "INSERT INTO PRECURSOR (ID, TRAML_ID, GROUP_LABEL, PRECURSOR_MZ, CHARGE, LIBRARY_INTENSITY, LIBRARY_RT, DECOY) VALUES (" << group_set_index << ",'" << compound.id << "',NULL," << precursor_mz_map[group_set_index] << "," << compound_charge << ",NULL,NULL" << "," << precursor_decoy_map[group_set_index] << "); ";
insert_precursor_compound_mapping << "INSERT INTO PRECURSOR_COMPOUND_MAPPING (PRECURSOR_ID, COMPOUND_ID) VALUES (" << group_set_index << "," << compound_set_index << "); ";
}
endProgress();
boost::erase(peptide_protein_map, boost::unique<boost::return_found_end>(boost::sort(peptide_protein_map)));
// OpenSWATH: Prepare peptide-protein mapping inserts
std::stringstream insert_peptide_protein_mapping;
progress = 0;
startProgress(0, peptide_protein_map.size(), "Prepare peptide - protein mapping");
for (std::vector<std::pair<int, int> >::iterator it = peptide_protein_map.begin(); it != peptide_protein_map.end(); ++it)
{
setProgress(progress++);
insert_peptide_protein_mapping << "INSERT INTO PEPTIDE_PROTEIN_MAPPING (PEPTIDE_ID, PROTEIN_ID) VALUES (" << it->first << "," << it->second << "); ";
}
endProgress();
// OpenSWATH: Prepare protein inserts
std::stringstream insert_protein_sql;
progress = 0;
startProgress(0, protein_set.size(), String("Prepare ") + protein_set.size() + " proteins");
for (Size i = 0; i < protein_set.size(); i++)
{
setProgress(progress++);
insert_protein_sql << "INSERT INTO PROTEIN (ID, PROTEIN_ACCESSION) VALUES (" << i << ",'" << protein_set[i] << "'); ";
}
endProgress();
// OpenSWATH: Prepare peptide inserts
std::stringstream insert_peptide_sql;
progress = 0;
startProgress(0, peptide_set.size(), String("Prepare ") + peptide_set.size() + " peptides");
for (std::vector<std::string>::iterator it = peptide_set.begin(); it != peptide_set.end(); ++it)
{
setProgress(progress++);
insert_peptide_sql << "INSERT INTO PEPTIDE (ID, UNMODIFIED_SEQUENCE, MODIFIED_SEQUENCE, DECOY) VALUES (" << std::distance(peptide_set.begin(),std::find(peptide_set.begin(), peptide_set.end(),*it)) << ",'" << AASequence::fromString(*it).toUnmodifiedString() << "','" << *it << "'," << 0 <<"); ";
}
endProgress();
// OpenSWATH: Prepare compound inserts
std::stringstream insert_compound_sql;
progress = 0;
startProgress(0, compound_set.size(), String("Prepare ") + compound_set.size() + " compounds");
for (std::vector<std::string>::iterator it = compound_set.begin(); it != compound_set.end(); ++it)
{
setProgress(progress++);
OpenMS::TargetedExperiment::Compound compound = targeted_exp.getCompoundByRef(*it);
insert_compound_sql << "INSERT INTO COMPOUND (ID, COMPOUND_NAME, SUM_FORMULA, SMILES, DECOY) VALUES (" << std::distance(compound_set.begin(),std::find(compound_set.begin(), compound_set.end(),*it)) << ",'" << compound.id << "','" << compound.molecular_formula << "','" << compound.smiles_string << "'," << 0 <<"); ";
}
endProgress();
std::cout << "Write PQP file" << std::endl;
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &zErrMsg);
// Execute SQL insert statement
std::string insert_protein_sql_str = insert_protein_sql.str();
rc = sqlite3_exec(db, insert_protein_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_peptide_protein_mapping_str = insert_peptide_protein_mapping.str();
rc = sqlite3_exec(db, insert_peptide_protein_mapping_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_peptide_sql_str = insert_peptide_sql.str();
rc = sqlite3_exec(db, insert_peptide_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_compound_sql_str = insert_compound_sql.str();
rc = sqlite3_exec(db, insert_compound_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_precursor_peptide_mapping_str = insert_precursor_peptide_mapping.str();
rc = sqlite3_exec(db, insert_precursor_peptide_mapping_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_precursor_compound_mapping_str = insert_precursor_compound_mapping.str();
rc = sqlite3_exec(db, insert_precursor_compound_mapping_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_precursor_sql_str = insert_precursor_sql.str();
rc = sqlite3_exec(db, insert_precursor_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_transition_sql_str = insert_transition_sql.str();
rc = sqlite3_exec(db, insert_transition_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_transition_peptide_mapping_sql_str = insert_transition_peptide_mapping_sql.str();
rc = sqlite3_exec(db, insert_transition_peptide_mapping_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
// Execute SQL insert statement
std::string insert_transition_precursor_mapping_sql_str = insert_transition_precursor_mapping_sql.str();
rc = sqlite3_exec(db, insert_transition_precursor_mapping_sql_str.c_str(), callback, 0, &zErrMsg);
if ( rc != SQLITE_OK )
{
sqlite3_free(zErrMsg);
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
zErrMsg);
}
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &zErrMsg);
sqlite3_close(db);
}
void ChromatogramExtractorAlgorithm::extractChromatograms(const OpenSwath::SpectrumAccessPtr input,
std::vector< OpenSwath::ChromatogramPtr >& output,
std::vector<ExtractionCoordinates> extraction_coordinates, double mz_extraction_window,
bool ppm, String filter)
{
Size input_size = input->getNrSpectra();
if (input_size < 1)
{
return;
}
if (output.size() != extraction_coordinates.size())
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Output and extraction coordinates need to have the same size");
}
int used_filter = getFilterNr_(filter);
// assert that they are sorted!
if (std::adjacent_find(extraction_coordinates.begin(), extraction_coordinates.end(),
ExtractionCoordinates::SortExtractionCoordinatesReverseByMZ) != extraction_coordinates.end())
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Input to extractChromatogram needs to be sorted by m/z");
}
//go through all spectra
startProgress(0, input_size, "Extracting chromatograms");
for (Size scan_idx = 0; scan_idx < input_size; ++scan_idx)
{
setProgress(scan_idx);
OpenSwath::SpectrumPtr sptr = input->getSpectrumById(scan_idx);
OpenSwath::SpectrumMeta s_meta = input->getSpectrumMetaById(scan_idx);
OpenSwath::BinaryDataArrayPtr mz_arr = sptr->getMZArray();
OpenSwath::BinaryDataArrayPtr int_arr = sptr->getIntensityArray();
std::vector<double>::const_iterator mz_start = mz_arr->data.begin();
std::vector<double>::const_iterator mz_end = mz_arr->data.end();
std::vector<double>::const_iterator mz_it = mz_arr->data.begin();
std::vector<double>::const_iterator int_it = int_arr->data.begin();
if (sptr->getMZArray()->data.size() == 0)
continue;
// go through all transitions / chromatograms which are sorted by
// ProductMZ. We can use this to step through the spectrum and at the
// same time step through the transitions. We increase the peak counter
// until we hit the next transition and then extract the signal.
for (Size k = 0; k < extraction_coordinates.size(); ++k)
{
double integrated_intensity = 0;
double current_rt = s_meta.RT;
if (extraction_coordinates[k].rt_end - extraction_coordinates[k].rt_start > 0 &&
(current_rt < extraction_coordinates[k].rt_start ||
current_rt > extraction_coordinates[k].rt_end) )
{
continue;
}
if (used_filter == 1)
{
extract_value_tophat( mz_start, mz_it, mz_end, int_it,
extraction_coordinates[k].mz, integrated_intensity, mz_extraction_window, ppm);
}
else if (used_filter == 2)
{
throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
// Time is first, intensity is second
output[k]->binaryDataArrayPtrs[0]->data.push_back(current_rt);
output[k]->binaryDataArrayPtrs[1]->data.push_back(integrated_intensity);
}
}
endProgress();
}
//***************************************************************************
// Function Name: WndProc(HWND, unsigned, WORD, LONG)
//
// Purpose: Processes messages for the main window.
//
BOOL CALLBACK DlgProc (
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam)
{
BOOL fReturn = TRUE;
HANDLE hThread = NULL;
HWND hwndBacklight = NULL;
static BOOL s_fIdled = FALSE;
int iRes;
TCHAR szBuf[MAX_PATH];
RECT rect; RECT rechteck;
HDC hdc;
// int iWidth;
PAINTSTRUCT ps;
int iW;
static HBRUSH hBrush;
HBRUSH hBrushOld;
switch(Msg)
{
case WM_INITDIALOG:
g_hWnd = hWnd;
// Initialize the dialog and softkey menu
if (FALSE == InitWindow(hWnd, IDR_MENU))
{
EndDialog(hWnd, -1);
}
// Start up the thread to get the power notifications
//g_hEventShutDown = CreateEvent(NULL, FALSE, FALSE, NULL);
//if (NULL != g_hEventShutDown)
//{
// g_hPowerNotificationThread =
// CreateThread(0, 0, PowerNotificationThread, NULL, 0, 0);
//}
///g_hSystemState = GetDlgItem(hwnd, IDC_SYSTEMSTATE);
//try to read strings from resource
if(iRes=LoadString(g_hInst, IDS_BTNWARMBOOT, szBuf, MAX_PATH))
wcscpy(_stringTable.szReboot, szBuf);
if(iRes=LoadString(g_hInst, IDS_BTNCANCEL, szBuf, MAX_PATH))
wcscpy(_stringTable.szCancel, szBuf);
if(iRes=LoadString(g_hInst, IDS_BTNSHUTDOWN, szBuf, MAX_PATH))
wcscpy(_stringTable.szShutdown, szBuf);
if(iRes=LoadString(g_hInst, IDS_BTNSUSPEND, szBuf, MAX_PATH))
wcscpy(_stringTable.szSuspend, szBuf);
if(iRes=LoadString(g_hInst, IDS_BTNCLEANBOOT, szBuf, MAX_PATH))
wcscpy(_stringTable.szCleanBoot, szBuf);
if(iRes=LoadString(g_hInst, IDS_DIALOGTEXT, szBuf, MAX_PATH))
wcscpy(_stringTable.szQuestion, szBuf);
//try to read strings from registry
if(! readReg()){
writeReg();
}
//add code to check for CN50
TCHAR platFormName[MAX_PATH];
if(ReadPlatformName(platFormName)==0){
if(wcsicmp(platFormName, L"CN50")==0)
ShowWindow(GetDlgItem(hWnd, IDC_BTNSHUTDOWN), SW_SHOW);
}
else
ShowWindow(GetDlgItem(hWnd, IDC_BTNSHUTDOWN), SW_HIDE);
SetWindowText(GetDlgItem(hWnd, IDC_DIALOGTEXT), _stringTable.szQuestion);
SetWindowText(GetDlgItem(hWnd, IDC_BTNWARMBOOT), _stringTable.szReboot);
SetWindowText(GetDlgItem(hWnd, IDC_BTNCANCEL), _stringTable.szCancel);
SetWindowText(GetDlgItem(hWnd, IDC_BTNSHUTDOWN), _stringTable.szShutdown);
SetWindowText(GetDlgItem(hWnd, IDC_BTNSUSPEND), _stringTable.szSuspend);
SetWindowText(GetDlgItem(hWnd, IDC_BTNCLEANBOOT), _stringTable.szCleanBoot);
hCountdown= GetDlgItem(hWnd, IDC_EDIT2);
SetWindowText(hCountdown, L"-");
hProgress = GetDlgItem(hWnd, IDC_PROGRESS1);
if (hProgress != NULL)
{
SendMessage(hProgress, PBM_SETRANGE, 0, MAKELPARAM(0, iMaxTime)); // set range from 0 to 30// 100
SendMessage(hProgress, PBM_SETSTEP, MAKEWPARAM(1, 0), 0);
}
startProgress(hWnd);
// Update the current state in the dialog
//UpdatePowerState();
break;
case WM_COMMAND:
DEBUGMSG(1, (L"WM_COMMAND with wmId=%04x\r\n", wParam));
EnableWindow(hWnd, FALSE);
SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
switch (wParam)
{
case IDM_QUIT:
EndDialog(hWnd, IDOK);
break;
//default: fReturn = FALSE;
case IDC_BTNCANCEL:
EndDialog(hWnd, IDCANCEL);
PostQuitMessage(1);
break;
case IDC_BTNSHUTDOWN:
EndDialog(hWnd, IDC_BTNSHUTDOWN);
//PostQuitMessage(2);
//CN50_Shutdown();
break;
case IDC_BTNSUSPEND:
EndDialog(hWnd, IDC_BTNSUSPEND);
//PostQuitMessage(3);
//SuspendPPC();
break;
case IDC_BTNWARMBOOT:
EndDialog(hWnd, IDC_BTNWARMBOOT);
//PostQuitMessage(4);
//ResetPocketPC();
break;
case IDC_BTNCLEANBOOT:
EndDialog(hWnd, IDC_BTNCLEANBOOT);
break;
default:
EnableWindow(hWnd, TRUE);
SetCursor(LoadCursor(NULL, IDC_ARROW));
ShowCursor(FALSE);
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
EnableWindow(hWnd, TRUE);
SetCursor(LoadCursor(NULL, IDC_ARROW));
ShowCursor(FALSE);
break;
case WM_DISPOSEDIALOG:
EndDialog(hWnd, IDCANCEL);
break;
case WM_STEP:
SendMessage(hProgress, PBM_STEPIT, 0, 0);
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code here...
//add rectangle instead of progressbar
GetWindowRect(hWnd, &rect);
//InvalidateRect(hWnd, &rect, FALSE);
rechteck.top=iMargin;
rechteck.left=iMargin;
iW=/* rect.right-iMargin - */iAutoend*((rect.right-iMargin)/iMaxTime);
rechteck.bottom=iProgressHeight;
hBrushOld = (HBRUSH) SelectObject(hdc, hBrush);
rechteck.right=iW;
iW = FillRect(hdc, &rechteck, hBrush); //(HBRUSH)COLOR_ACTIVECAPTION
SelectObject(hdc, hBrushOld);
EndPaint(hWnd, &ps);
ReleaseDC(hWnd, hdc);
break;
//case WM_TIMER:
// // Set the system state to full power
// KillTimer(hWnd, 1);
// SetSystemPowerState(NULL, POWER_STATE_ON, 0);
// s_fIdled = FALSE;
// break;
case WM_DESTROY:
SetBacklightRequirement(FALSE);
EnableWindow(hWnd, TRUE);
SetCursor(LoadCursor(NULL, IDC_ARROW));
ShowCursor(FALSE);
// Kill the power notification thread
if (NULL != g_hEventShutDown)
{
SetEvent(g_hEventShutDown);
if (NULL != g_hPowerNotificationThread)
{
WaitForSingleObject(g_hPowerNotificationThread , INFINITE);
CloseHandle(g_hPowerNotificationThread);
}
CloseHandle(g_hEventShutDown);
}
DeleteObject(hBrush);
break;
default:
fReturn = FALSE;
break;
}
return fReturn;
}
/**
@brief Applies the peak-picking algorithm to a map (MSExperiment). This
method picks peaks for each scan in the map consecutively. The resulting
picked peaks are written to the output map.
Currently we have to give up const-correctness but we know that everything on disc is constant
*/
void PeakPickerHiRes::pickExperiment(/* const */ OnDiscMSExperiment& input, PeakMap& output, const bool check_spectrum_type) const
{
// make sure that output is clear
output.clear(true);
// copy experimental settings
static_cast<ExperimentalSettings &>(output) = *input.getExperimentalSettings();
Size progress = 0;
startProgress(0, input.size() + input.getNrChromatograms(), "picking peaks");
// resize output with respect to input
output.resize(input.size());
if (input.getNrSpectra() > 0)
{
for (Size scan_idx = 0; scan_idx != input.size(); ++scan_idx)
{
if (ms_levels_.empty()) //auto mode
{
MSSpectrum s = input[scan_idx];
s.sortByPosition();
// determine type of spectral data (profile or centroided)
SpectrumSettings::SpectrumType spectrumType = s.getType();
if (spectrumType == SpectrumSettings::CENTROID)
{
output[scan_idx] = input[scan_idx];
}
else
{
pick(s, output[scan_idx]);
}
}
else if (!ListUtils::contains(ms_levels_, input[scan_idx].getMSLevel())) // manual mode
{
output[scan_idx] = input[scan_idx];
}
else
{
MSSpectrum s = input[scan_idx];
s.sortByPosition();
// determine type of spectral data (profile or centroided)
SpectrumSettings::SpectrumType spectrum_type = s.getType();
if (spectrum_type == SpectrumSettings::CENTROID && check_spectrum_type)
{
throw OpenMS::Exception::IllegalArgument(__FILE__, __LINE__, __FUNCTION__, "Error: Centroided data provided but profile spectra expected.");
}
pick(s, output[scan_idx]);
}
setProgress(++progress);
}
}
for (Size i = 0; i < input.getNrChromatograms(); ++i)
{
MSChromatogram chromatogram;
pick(input.getChromatogram(i), chromatogram);
output.addChromatogram(chromatogram);
setProgress(++progress);
}
endProgress();
return;
}
ZSwcTree* ZNeuronTracer::trace(Stack *stack, bool doResampleAfterTracing)
{
startProgress();
ZSwcTree *tree = NULL;
//Extract seeds
//First mask
std::cout << "Binarizing ..." << std::endl;
/* <bw> allocated */
Stack *bw = binarize(stack);
C_Stack::translate(bw, GREY, 1);
advanceProgress(0.05);
std::cout << "Removing noise ..." << std::endl;
/* <mask> allocated */
Stack *mask = bwsolid(bw);
advanceProgress(0.05);
/* <bw> freed */
C_Stack::kill(bw);
//Thin line mask
/* <mask2> allocated */
Stack *mask2 = NULL;
if (m_enhancingMask) {
std::cout << "Enhancing thin branches ..." << std::endl;
mask2 = enhanceLine(stack);
advanceProgress(0.05);
}
if (mask2 != NULL) {
std::cout << "Making mask for thin branches ..." << std::endl;
ZStackBinarizer binarizer;
binarizer.setMethod(ZStackBinarizer::BM_LOCMAX);
binarizer.setRetryCount(5);
binarizer.setMinObjectSize(27);
if (binarizer.binarize(mask2) == false) {
std::cout << "Thresholding failed" << std::endl;
C_Stack::kill(mask2);
mask2 = NULL;
}
}
/* <mask2> freed */
if (mask2 != NULL) {
C_Stack::translate(mask2, GREY, 1);
Stack_Or(mask, mask2, mask);
C_Stack::kill(mask2);
mask2 = NULL;
}
advanceProgress(0.05);
//Trace each seed
std::cout << "Extracting seed points ..." << std::endl;
/* <seedPointArray> allocated */
Geo3d_Scalar_Field *seedPointArray = extractSeed(mask);
m_mask = mask;
advanceProgress(0.05);
std::cout << "Sorting seeds ..." << std::endl;
ZNeuronTraceSeeder seeder;
setTraceScoreThreshold(TRACING_SEED);
m_baseMask = seeder.sortSeed(seedPointArray, stack, m_traceWorkspace);
#ifdef _DEBUG_2
C_Stack::write(GET_TEST_DATA_DIR + "/test.tif", m_baseMask);
#endif
advanceProgress(0.1);
/* <seedPointArray> freed */
Kill_Geo3d_Scalar_Field(seedPointArray);
std::vector<Local_Neuroseg>& locsegArray = seeder.getSeedArray();
std::vector<double>& scoreArray = seeder.getScoreArray();
std::cout << "Tracing ..." << std::endl;
/* <chainArray> allocated */
std::vector<Locseg_Chain*> chainArray = trace(stack, locsegArray, scoreArray);
if (m_recover > 0) {
std::vector<Locseg_Chain*> newChainArray = recover(stack);
chainArray.insert(
chainArray.end(), newChainArray.begin(), newChainArray.end());
}
advanceProgress(0.1);
chainArray = screenChain(stack, chainArray);
advanceProgress(0.3);
/* <mask2> freed */
// C_Stack::kill(mask);
std::cout << "Reconstructing ..." << std::endl;
ZNeuronConstructor constructor;
constructor.setWorkspace(m_connWorkspace);
constructor.setSignal(stack);
//Create neuron structure
BOOL oldSpTest = m_connWorkspace->sp_test;
if (chainArray.size() > 1000) {
std::cout << "Too many chains: " << chainArray.size() << std::endl;
std::cout << "Turn off shortest path test" << std::endl;
m_connWorkspace->sp_test = FALSE;
}
/* free <chainArray> */
tree = constructor.reconstruct(chainArray);
m_connWorkspace->sp_test = oldSpTest;
advanceProgress(0.1);
//Post process
Swc_Tree_Remove_Zigzag(tree->data());
Swc_Tree_Tune_Branch(tree->data());
Swc_Tree_Remove_Spur(tree->data());
Swc_Tree_Merge_Close_Node(tree->data(), 0.01);
Swc_Tree_Remove_Overshoot(tree->data());
if (doResampleAfterTracing) {
ZSwcResampler resampler;
resampler.optimalDownsample(tree);
}
advanceProgress(0.1);
std::cout << "Done!" << std::endl;
endProgress();
return tree;
}
void Callbacks::emitStartProgress( const QString & info )
{ emit startProgress( info ); }
void MRMDecoy::generateDecoys(OpenMS::TargetedExperiment& exp, OpenMS::TargetedExperiment& dec,
String method, String decoy_tag, double identity_threshold, int max_attempts,
double mz_threshold, double mz_shift, bool exclude_similar,
double similarity_threshold, bool remove_CNterminal_mods, double precursor_mass_shift,
std::vector<String> fragment_types, std::vector<size_t> fragment_charges,
bool enable_specific_losses, bool enable_unspecific_losses, bool remove_unannotated,
int round_decPow)
{
MRMIonSeries mrmis;
MRMDecoy::PeptideVectorType peptides, decoy_peptides;
MRMDecoy::ProteinVectorType proteins, decoy_proteins;
MRMDecoy::TransitionVectorType decoy_transitions;
for (Size i = 0; i < exp.getProteins().size(); i++)
{
OpenMS::TargetedExperiment::Protein protein = exp.getProteins()[i];
protein.id = decoy_tag + protein.id;
proteins.push_back(protein);
}
std::vector<String> exclusion_peptides;
// Go through all peptides and apply the decoy method to the sequence
// (pseudo-reverse, reverse or shuffle). Then set the peptides and proteins of the decoy
// experiment.
for (Size pep_idx = 0; pep_idx < exp.getPeptides().size(); ++pep_idx)
{
OpenMS::TargetedExperiment::Peptide peptide = exp.getPeptides()[pep_idx];
// continue if the peptide has C/N terminal modifications and we should exclude them
if (remove_CNterminal_mods && MRMDecoy::has_CNterminal_mods(peptide)) {continue; }
peptide.id = decoy_tag + peptide.id;
OpenMS::String original_sequence = peptide.sequence;
if (!peptide.getPeptideGroupLabel().empty())
{
peptide.setPeptideGroupLabel(decoy_tag + peptide.getPeptideGroupLabel());
}
if (method == "pseudo-reverse")
{
peptide = MRMDecoy::pseudoreversePeptide(peptide);
}
else if (method == "reverse")
{
peptide = MRMDecoy::reversePeptide(peptide);
}
else if (method == "shuffle")
{
peptide = MRMDecoy::shufflePeptide(peptide, identity_threshold, -1, max_attempts);
}
for (Size prot_idx = 0; prot_idx < peptide.protein_refs.size(); ++prot_idx)
{
peptide.protein_refs[prot_idx] = decoy_tag + peptide.protein_refs[prot_idx];
}
if (MRMDecoy::AASequenceIdentity(original_sequence, peptide.sequence) > identity_threshold)
{
if (!exclude_similar)
{
std::cout << "Target sequence: " << original_sequence << " Decoy sequence: " << peptide.sequence << " Sequence identity: " << MRMDecoy::AASequenceIdentity(original_sequence, peptide.sequence) << " Identity threshold: " << identity_threshold << std::endl;
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "AA Sequences are too similar. Either decrease identity_threshold and increase max_attempts for the shuffle method or set flag exclude_similar.");
}
else
{
exclusion_peptides.push_back(peptide.id);
}
}
peptides.push_back(peptide);
}
dec.setPeptides(peptides); // temporary set peptides, overwrite later again!
// hash of the peptide reference containing all transitions
MRMDecoy::PeptideTransitionMapType peptide_trans_map;
for (Size i = 0; i < exp.getTransitions().size(); i++)
{
peptide_trans_map[exp.getTransitions()[i].getPeptideRef()].push_back(&exp.getTransitions()[i]);
}
Size progress = 0;
startProgress(0, exp.getTransitions().size(), "Creating decoys");
for (MRMDecoy::PeptideTransitionMapType::iterator pep_it = peptide_trans_map.begin();
pep_it != peptide_trans_map.end(); ++pep_it)
{
String peptide_ref = pep_it->first;
String decoy_peptide_ref = decoy_tag + pep_it->first; // see above, the decoy peptide id is computed deterministically from the target id
const TargetedExperiment::Peptide target_peptide = exp.getPeptideByRef(peptide_ref);
// continue if the peptide has C/N terminal modifications and we should exclude them
if (remove_CNterminal_mods && MRMDecoy::has_CNterminal_mods(target_peptide)) {continue;}
const TargetedExperiment::Peptide decoy_peptide = dec.getPeptideByRef(decoy_peptide_ref);
OpenMS::AASequence target_peptide_sequence = TargetedExperimentHelper::getAASequence(target_peptide);
OpenMS::AASequence decoy_peptide_sequence = TargetedExperimentHelper::getAASequence(decoy_peptide);
int decoy_charge = 1;
int target_charge = 1;
if (decoy_peptide.hasCharge()) {decoy_charge = decoy_peptide.getChargeState();}
if (target_peptide.hasCharge()) {target_charge = target_peptide.getChargeState();}
MRMIonSeries::IonSeries decoy_ionseries = mrmis.getIonSeries(decoy_peptide_sequence, decoy_charge, fragment_types, fragment_charges, enable_specific_losses, enable_unspecific_losses, round_decPow);
MRMIonSeries::IonSeries target_ionseries = mrmis.getIonSeries(target_peptide_sequence, target_charge, fragment_types, fragment_charges, enable_specific_losses, enable_unspecific_losses, round_decPow);
for (Size i = 0; i < pep_it->second.size(); i++)
{
setProgress(++progress);
const ReactionMonitoringTransition tr = *(pep_it->second[i]);
if (!tr.isDetectingTransition() || tr.getDecoyTransitionType() == ReactionMonitoringTransition::DECOY)
{
continue;
}
ReactionMonitoringTransition decoy_tr = tr; // copy the target transition
decoy_tr.setNativeID(decoy_tag + tr.getNativeID());
decoy_tr.setDecoyTransitionType(ReactionMonitoringTransition::DECOY);
decoy_tr.setPrecursorMZ(tr.getPrecursorMZ() + precursor_mass_shift); // fix for TOPPView: Duplicate precursor MZ is not displayed.
// determine the current annotation for the target ion and then select
// the appropriate decoy ion for this target transition
std::pair<String, double> targetion = mrmis.annotateIon(target_ionseries, tr.getProductMZ(), mz_threshold);
std::pair<String, double> decoyion = mrmis.getIon(decoy_ionseries, targetion.first);
if (method == "shift")
{
decoy_tr.setProductMZ(decoyion.second + mz_shift);
}
else
{
decoy_tr.setProductMZ(decoyion.second);
}
decoy_tr.setPeptideRef(decoy_tag + tr.getPeptideRef());
if (decoyion.second > 0)
{
if (similarity_threshold >= 0)
{
if (std::fabs(tr.getProductMZ() - decoy_tr.getProductMZ()) < similarity_threshold)
{
if (!exclude_similar)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Fragment ions are too similar. Either decrease similarity_threshold or set flag exclude_similar.");
}
else
{
exclusion_peptides.push_back(decoy_tr.getPeptideRef());
}
}
}
decoy_transitions.push_back(decoy_tr);
}
else
{
if (remove_unannotated)
{
exclusion_peptides.push_back(decoy_tr.getPeptideRef());
}
else
{
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Decoy fragment ion for target fragment ion " + String(targetion.first) + " of peptide " + target_peptide_sequence.toString() + " with precursor charge " + String(target_peptide.getChargeState()) + " could not be mapped. Please check whether it is a valid ion and enable losses or removal of terminal modifications if necessary. Skipping of unannotated target assays is available as last resort.");
}
}
} // end loop over transitions
} // end loop over peptides
endProgress();
MRMDecoy::TransitionVectorType filtered_decoy_transitions;
for (MRMDecoy::TransitionVectorType::iterator tr_it = decoy_transitions.begin(); tr_it != decoy_transitions.end(); ++tr_it)
{
if (std::find(exclusion_peptides.begin(), exclusion_peptides.end(), tr_it->getPeptideRef()) == exclusion_peptides.end())
{
filtered_decoy_transitions.push_back(*tr_it);
}
}
dec.setTransitions(filtered_decoy_transitions);
std::vector<String> protein_ids;
for (Size i = 0; i < peptides.size(); ++i)
{
TargetedExperiment::Peptide peptide = peptides[i];
// Check if peptide has any transitions left
if (std::find(exclusion_peptides.begin(), exclusion_peptides.end(), peptide.id) == exclusion_peptides.end())
{
decoy_peptides.push_back(peptide);
for (Size j = 0; j < peptide.protein_refs.size(); ++j)
{
protein_ids.push_back(peptide.protein_refs[j]);
}
}
else
{
LOG_DEBUG << "[peptide] Skipping " << peptide.id << std::endl;
}
}
for (Size i = 0; i < proteins.size(); ++i)
{
OpenMS::TargetedExperiment::Protein protein = proteins[i];
// Check if protein has any peptides left
if (find(protein_ids.begin(), protein_ids.end(), protein.id) != protein_ids.end())
{
decoy_proteins.push_back(protein);
}
else
{
LOG_DEBUG << "[protein] Skipping " << protein.id << std::endl;
}
}
dec.setPeptides(decoy_peptides);
dec.setProteins(decoy_proteins);
}
void AverageLinkage::operator()(DistanceMatrix<float> & original_distance, std::vector<BinaryTreeNode> & cluster_tree, const float threshold /*=1*/) const
{
// input MUST have >= 2 elements!
if (original_distance.dimensionsize() < 2)
{
throw ClusterFunctor::InsufficientInput(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Distance matrix to start from only contains one element");
}
std::vector<std::set<Size> > clusters(original_distance.dimensionsize());
for (Size i = 0; i < original_distance.dimensionsize(); ++i)
{
clusters[i].insert(i);
}
cluster_tree.clear();
cluster_tree.reserve(original_distance.dimensionsize() - 1);
// Initial minimum-distance pair
original_distance.updateMinElement();
std::pair<Size, Size> min = original_distance.getMinElementCoordinates();
Size overall_cluster_steps(original_distance.dimensionsize());
startProgress(0, original_distance.dimensionsize(), "clustering data");
while (original_distance(min.second, min.first) < threshold)
{
//grow the tree
cluster_tree.push_back(BinaryTreeNode(*(clusters[min.second].begin()), *(clusters[min.first].begin()), original_distance(min.first, min.second)));
if (cluster_tree.back().left_child > cluster_tree.back().right_child)
{
std::swap(cluster_tree.back().left_child, cluster_tree.back().right_child);
}
if (original_distance.dimensionsize() > 2)
{
//pick minimum-distance pair i,j and merge them
//calculate parameter for lance-williams formula
float alpha_i = (float)(clusters[min.first].size() / (float)(clusters[min.first].size() + clusters[min.second].size()));
float alpha_j = (float)(clusters[min.second].size() / (float)(clusters[min.first].size() + clusters[min.second].size()));
//~ std::cout << alpha_i << '\t' << alpha_j << std::endl;
//pushback elements of second to first (and then erase second)
clusters[min.second].insert(clusters[min.first].begin(), clusters[min.first].end());
// erase first one
clusters.erase(clusters.begin() + min.first);
//update original_distance matrix
//average linkage: new distance between clusters is the minimum distance between elements of each cluster
//lance-williams update for d((i,j),k): (m_i/m_i+m_j)* d(i,k) + (m_j/m_i+m_j)* d(j,k) ; m_x is the number of elements in cluster x
for (Size k = 0; k < min.second; ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(min.second, k, (alpha_i * dik + alpha_j * djk));
}
for (Size k = min.second + 1; k < original_distance.dimensionsize(); ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(k, min.second, (alpha_i * dik + alpha_j * djk));
}
//reduce
original_distance.reduce(min.first);
//update minimum-distance pair
original_distance.updateMinElement();
//get min-pair from triangular matrix
min = original_distance.getMinElementCoordinates();
}
else
{
break;
}
setProgress(overall_cluster_steps - original_distance.dimensionsize());
//repeat until only two cluster remains, last step skips matrix operations
}
//fill tree with dummy nodes
Size sad(*clusters.front().begin());
for (Size i = 1; (i < clusters.size()) && (cluster_tree.size() < cluster_tree.capacity()); ++i)
{
cluster_tree.push_back(BinaryTreeNode(sad, *clusters[i].begin(), -1.0));
}
endProgress();
}
void SingleLinkage::operator()(DistanceMatrix<float> & original_distance, std::vector<BinaryTreeNode> & cluster_tree, const float threshold /*=1*/) const
{
// input MUST have >= 2 elements!
if (original_distance.dimensionsize() < 2)
{
throw ClusterFunctor::InsufficientInput(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Distance matrix to start from only contains one element");
}
cluster_tree.clear();
if (threshold < 1)
{
LOG_ERROR << "You tried to use Single Linkage clustering with a threshold. This is currently not supported!" << std::endl;
throw Exception::NotImplemented(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
}
//SLINK
std::vector<Size> pi;
pi.reserve(original_distance.dimensionsize());
std::vector<float> lambda;
lambda.reserve(original_distance.dimensionsize());
startProgress(0, original_distance.dimensionsize(), "clustering data");
//initialize first pointer values
pi.push_back(0);
lambda.push_back(std::numeric_limits<float>::max());
for (Size k = 1; k < original_distance.dimensionsize(); ++k)
{
std::vector<float> row_k;
row_k.reserve(k);
//initialize pointer values for element to cluster
pi.push_back(k);
lambda.push_back(std::numeric_limits<float>::max());
// get the right distances
for (Size i = 0; i < k; ++i)
{
row_k.push_back(original_distance.getValue(i, k));
}
//calculate pointer values for element k
for (Size i = 0; i < k; ++i)
{
if (lambda[i] >= row_k[i])
{
row_k[pi[i]] = std::min(row_k[pi[i]], lambda[i]);
lambda[i] = row_k[i];
pi[i] = k;
}
else
{
row_k[pi[i]] = std::min(row_k[pi[i]], row_k[i]);
}
}
//update clustering if necessary
for (Size i = 0; i < k; ++i)
{
if (lambda[i] >= lambda[pi[i]])
{
pi[i] = k;
}
}
setProgress(k);
}
for (Size i = 0; i < pi.size() - 1; ++i)
{
//strict order is always kept in algorithm: i < pi[i]
cluster_tree.push_back(BinaryTreeNode(i, pi[i], lambda[i]));
//~ std::cout << i << '\n' << pi[i] << '\n' << lambda[i] << std::endl;
}
//sort pre-tree
std::sort(cluster_tree.begin(), cluster_tree.end(), compareBinaryTreeNode);
// convert -pre-tree to correct format
for (Size i = 0; i < cluster_tree.size(); ++i)
{
if (cluster_tree[i].right_child < cluster_tree[i].left_child)
{
std::swap(cluster_tree[i].left_child, cluster_tree[i].right_child);
}
for (Size k = i + 1; k < cluster_tree.size(); ++k)
{
if (cluster_tree[k].left_child == cluster_tree[i].right_child)
{
cluster_tree[k].left_child = cluster_tree[i].left_child;
}
else if (cluster_tree[k].left_child > cluster_tree[i].right_child)
{
--cluster_tree[k].left_child;
}
if (cluster_tree[k].right_child == cluster_tree[i].right_child)
{
cluster_tree[k].right_child = cluster_tree[i].left_child;
}
else if (cluster_tree[k].right_child > cluster_tree[i].right_child)
{
--cluster_tree[k].right_child;
}
}
}
//~ prepare to redo clustering to get all indices for binarytree in min index element representation
std::vector<std::set<Size> > clusters(original_distance.dimensionsize());
for (Size i = 0; i < original_distance.dimensionsize(); ++i)
{
clusters[i].insert(i);
}
for (Size cluster_step = 0; cluster_step < cluster_tree.size(); ++cluster_step)
{
Size new_left_child = *(clusters[cluster_tree[cluster_step].left_child].begin());
Size new_right_child = *(clusters[cluster_tree[cluster_step].right_child].begin());
clusters[cluster_tree[cluster_step].left_child].insert(clusters[cluster_tree[cluster_step].right_child].begin(), clusters[cluster_tree[cluster_step].right_child].end());
clusters.erase(clusters.begin() + cluster_tree[cluster_step].right_child);
std::swap(cluster_tree[cluster_step].left_child, new_left_child);
std::swap(cluster_tree[cluster_step].right_child, new_right_child);
if (cluster_tree[cluster_step].left_child > cluster_tree[cluster_step].right_child)
{
std::swap(cluster_tree[cluster_step].left_child, cluster_tree[cluster_step].right_child);
}
}
endProgress();
}
vector<MultiplexFilterResult> MultiplexFilteringCentroided::filter()
{
// progress logger
unsigned progress = 0;
startProgress(0, patterns_.size() * exp_picked_.size(), "filtering LC-MS data");
// list of filter results for each peak pattern
vector<MultiplexFilterResult> filter_results;
// loop over patterns
for (unsigned pattern = 0; pattern < patterns_.size(); ++pattern)
{
// data structure storing peaks which pass all filters
MultiplexFilterResult result;
// iterate over spectra
for (PeakMap::Iterator it_rt_picked = exp_picked_.begin(); it_rt_picked < exp_picked_.end(); ++it_rt_picked)
{
// skip empty spectra
if (it_rt_picked->empty())
{
continue;
}
setProgress(++progress);
int spectrum = it_rt_picked - exp_picked_.begin(); // index of the spectrum in exp_picked_
double rt_picked = it_rt_picked->getRT();
// vectors of peak details
vector<double> peak_position;
vector<double> peak_intensity;
peak_position.reserve(it_rt_picked->size());
peak_intensity.reserve(it_rt_picked->size());
for (MSSpectrum<Peak1D>::Iterator it_mz = it_rt_picked->begin(); it_mz < it_rt_picked->end(); ++it_mz)
{
peak_position.push_back(it_mz->getMZ());
peak_intensity.push_back(it_mz->getIntensity());
}
// iterate over peaks in spectrum (mz)
for (unsigned peak = 0; peak < peak_position.size(); ++peak)
{
/**
* Filter (1): m/z position and blacklist filter
* Are there non-black peaks with the expected relative m/z shifts?
*/
vector<double> mz_shifts_actual; // actual m/z shifts (differ slightly from expected m/z shifts)
vector<int> mz_shifts_actual_indices; // peak indices in the spectrum corresponding to the actual m/z shifts
mz_shifts_actual.reserve(patterns_[pattern].getMZShiftCount());
mz_shifts_actual_indices.reserve(patterns_[pattern].getMZShiftCount());
int peaks_found_in_all_peptides = positionsAndBlacklistFilter_(patterns_[pattern], spectrum, peak_position, peak, mz_shifts_actual, mz_shifts_actual_indices);
if (peaks_found_in_all_peptides < peaks_per_peptide_min_)
{
continue;
}
/**
* Filter (2): blunt intensity filter
* Are the mono-isotopic peak intensities of all peptides above the cutoff?
*/
bool bluntVeto = monoIsotopicPeakIntensityFilter_(patterns_[pattern], spectrum, mz_shifts_actual_indices);
if (bluntVeto)
{
continue;
}
/**
* Filter (3): non-local intensity filter
* Are the peak intensities of all peptides above the cutoff?
*/
std::vector<double> intensities_actual; // peak intensities @ m/z peak position + actual m/z shift
int peaks_found_in_all_peptides_centroided = nonLocalIntensityFilter_(patterns_[pattern], spectrum, mz_shifts_actual_indices, intensities_actual, peaks_found_in_all_peptides);
if (peaks_found_in_all_peptides_centroided < peaks_per_peptide_min_)
{
continue;
}
/**
* Filter (4): zeroth peak filter
* There should not be a significant peak to the left of the mono-isotopic
* (i.e. first) peak.
*/
bool zero_peak = zerothPeakFilter_(patterns_[pattern], intensities_actual);
if (zero_peak)
{
continue;
}
/**
* Filter (5): peptide similarity filter
* How similar are the isotope patterns of the peptides?
*/
bool peptide_similarity = peptideSimilarityFilter_(patterns_[pattern], intensities_actual, peaks_found_in_all_peptides_centroided);
if (!peptide_similarity)
{
continue;
}
/**
* Filter (6): averagine similarity filter
* Does each individual isotope pattern resemble a peptide?
*/
bool averagine_similarity = averagineSimilarityFilter_(patterns_[pattern], intensities_actual, peaks_found_in_all_peptides_centroided, peak_position[peak]);
if (!averagine_similarity)
{
continue;
}
/**
* All filters passed.
*/
// add the peak to the result
vector<MultiplexFilterResultRaw> results_raw;
result.addFilterResultPeak(peak_position[peak], rt_picked, mz_shifts_actual, intensities_actual, results_raw);
// blacklist peaks in the current spectrum and the two neighbouring ones
blacklistPeaks_(patterns_[pattern], spectrum, mz_shifts_actual_indices, peaks_found_in_all_peptides_centroided);
}
}
// add results of this pattern to list
filter_results.push_back(result);
}
endProgress();
return filter_results;
}
void PoseClusteringShiftSuperimposer::run(const ConsensusMap & map_model, const ConsensusMap & map_scene, TransformationDescription & transformation)
{
typedef ConstRefVector<ConsensusMap> PeakPointerArray_;
typedef Math::LinearInterpolation<double, double> LinearInterpolationType_;
LinearInterpolationType_ shift_hash_;
// OLD STUFF
// LinearInterpolationType_ scaling_hash_1;
// LinearInterpolationType_ scaling_hash_2;
// LinearInterpolationType_ shift_hash_;
// LinearInterpolationType_ rt_high_hash_;
/// Maximum deviation in mz of two partner points
const double mz_pair_max_distance = param_.getValue("mz_pair_max_distance");
/// Size of each shift bucket
const double shift_bucket_size = param_.getValue("shift_bucket_size");
const UInt struc_elem_length_datapoints = 21; // MAGIC ALERT: number of data points in structuring element for tophat filter, which removes baseline from histogram
const double scaling_histogram_crossing_slope = 3.0; // MAGIC ALERT: used when distinguishing noise level and enriched histogram bins
const double scaling_cutoff_stdev_multiplier = 1.5; // MAGIC ALERT: multiplier for stdev in cutoff for outliers
const UInt loops_mean_stdev_cutoff = 3; // MAGIC ALERT: number of loops in stdev cutoff for outliers
startProgress(0, 100, "shift pose clustering");
UInt actual_progress = 0;
setProgress(++actual_progress);
// Optionally, we will write dumps of the hash table buckets.
bool do_dump_buckets = false;
String dump_buckets_basename;
if (param_.getValue("dump_buckets") != "")
{
do_dump_buckets = true;
dump_buckets_basename = param_.getValue("dump_buckets");
}
setProgress(++actual_progress);
// Even more optionally, we will write dumps of the hashed pairs.
bool do_dump_pairs = false;
String dump_pairs_basename;
if (param_.getValue("dump_pairs") != "")
{
do_dump_pairs = true;
dump_pairs_basename = param_.getValue("dump_pairs");
}
setProgress(++actual_progress);
//**************************************************************************
// Select the most abundant data points only. After that, disallow modifications
// (we tend to have annoying issues with const_iterator versus iterator).
PeakPointerArray_ model_map_ini(map_model.begin(), map_model.end());
const PeakPointerArray_ & model_map(model_map_ini);
PeakPointerArray_ scene_map_ini(map_scene.begin(), map_scene.end());
const PeakPointerArray_ & scene_map(scene_map_ini);
{
// truncate the data as necessary
// casting to SignedSize is done on PURPOSE here! (num_used_points will be maximal if -1 is used)
const Size num_used_points = (SignedSize) param_.getValue("num_used_points");
if (model_map_ini.size() > num_used_points)
{
model_map_ini.sortByIntensity(true);
model_map_ini.resize(num_used_points);
}
model_map_ini.sortByComparator(Peak2D::MZLess());
setProgress(++actual_progress);
if (scene_map_ini.size() > num_used_points)
{
scene_map_ini.sortByIntensity(true);
scene_map_ini.resize(num_used_points);
}
scene_map_ini.sortByComparator(Peak2D::MZLess());
setProgress(++actual_progress);
// Note: model_map_ini and scene_map_ini will not be used further below
}
setProgress((actual_progress = 10));
//**************************************************************************
// Preprocessing
// get RT ranges (NOTE: we trust that min and max have been updated in the
// ConsensusMap::convert() method !)
const double model_low = map_model.getMin()[ConsensusFeature::RT];
const double scene_low = map_scene.getMin()[ConsensusFeature::RT];
const double model_high = map_model.getMax()[ConsensusFeature::RT];
const double scene_high = map_scene.getMax()[ConsensusFeature::RT];
// OLD STUFF
// const double rt_low = (maps[0].getMin()[ConsensusFeature::RT] + maps[1].getMin()[ConsensusFeature::RT]) / 2.;
// const double rt_high = (maps[0].getMax()[ConsensusFeature::RT] + maps[1].getMax()[ConsensusFeature::RT]) / 2.;
// Initialize the hash tables: shift_hash_
// OLD STUFF: was: rt_scaling_hash_, rt_low_hash_, and rt_high_hash_
{
// (over)estimate the required number of buckets for shifting
double max_shift = param_.getValue("max_shift");
// actually the largest possible shift can be much smaller, depending on the data
do
{
if (max_shift < 0)
max_shift = -max_shift;
// ...ml@@@mh........ , ........ml@@@mh...
// ........sl@@@sh... , ...sl@@@sh........
double diff;
diff = model_high - scene_low;
if (diff < 0)
diff = -diff;
if (max_shift > diff)
max_shift = diff;
diff = model_low - scene_high;
if (diff < 0)
diff = -diff;
if (max_shift > diff)
max_shift = diff;
}
while (0);
const Int shift_buckets_num_half = 4 + (Int) ceil((max_shift) / shift_bucket_size);
const Int shift_buckets_num = 1 + 2 * shift_buckets_num_half;
shift_hash_.getData().clear();
shift_hash_.getData().resize(shift_buckets_num);
shift_hash_.setMapping(shift_bucket_size, shift_buckets_num_half, 0);
}
setProgress(++actual_progress);
//**************************************************************************
// compute the ratio of the total intensities of both maps, for normalization
double total_intensity_ratio;
do
{
double total_int_model_map = 0;
for (Size i = 0; i < model_map.size(); ++i)
{
total_int_model_map += model_map[i].getIntensity();
}
setProgress(++actual_progress);
double total_int_scene_map = 0;
for (Size i = 0; i < scene_map.size(); ++i)
{
total_int_scene_map += scene_map[i].getIntensity();
}
setProgress(++actual_progress);
// ... and finally ...
total_intensity_ratio = total_int_model_map / total_int_scene_map;
}
while (0); // (the extra syntax helps with code folding in eclipse!)
setProgress((actual_progress = 20));
/// The serial number is incremented for each invocation of this, to avoid overwriting of hash table dumps.
static Int dump_buckets_serial = 0;
++dump_buckets_serial;
//**************************************************************************
// Hashing
// Compute the transformations between each point pair in the model map
// and each point pair in the scene map and hash the shift
// transformation.
// To speed up the calculation of the final transformation, we confine the number of
// considered point pairs. We match a point p in the model map only onto those points p'
// in the scene map that lie in a certain mz interval.
Size const model_map_size = model_map.size(); // i /* OLD STUFF: also: j */
Size const scene_map_size = scene_map.size(); // k /* OLD STUFF: also: l */
const double winlength_factor_baseline = 0.1; // MAGIC ALERT: Each window is given unit weight. If there are too many pairs for a window, the individual contributions will be very small, but running time will be high, so we provide a cutoff for this. Typically this will exclude compounds which elute over the whole retention time range from consideration.
///////////////////////////////////////////////////////////////////
// Hashing: Estimate the shift
do // begin of hashing (the extra syntax helps with code folding in eclipse!)
{
String dump_pairs_filename;
std::ofstream dump_pairs_file;
if (do_dump_pairs)
{
dump_pairs_filename = dump_pairs_basename + String(dump_buckets_serial);
dump_pairs_file.open(dump_pairs_filename.c_str());
dump_pairs_file << "#" << ' ' << "i" << ' ' << "k" << std::endl;
}
setProgress(++actual_progress);
// first point in model map
for (Size i = 0, i_low = 0, i_high = 0, k_low = 0, k_high = 0; i < model_map_size - 1; ++i)
{
setProgress(actual_progress + float(i) / model_map_size * 10.f);
// Adjust window around i in model map
while (i_low < model_map_size && model_map[i_low].getMZ() < model_map[i].getMZ() - mz_pair_max_distance)
++i_low;
while (i_high < model_map_size && model_map[i_high].getMZ() <= model_map[i].getMZ() + mz_pair_max_distance)
++i_high;
double i_winlength_factor = 1. / (i_high - i_low);
i_winlength_factor -= winlength_factor_baseline;
if (i_winlength_factor <= 0)
continue;
// Adjust window around k in scene map
while (k_low < scene_map_size && scene_map[k_low].getMZ() < model_map[i].getMZ() - mz_pair_max_distance)
++k_low;
while (k_high < scene_map_size && scene_map[k_high].getMZ() <= model_map[i].getMZ() + mz_pair_max_distance)
++k_high;
// first point in scene map
for (Size k = k_low; k < k_high; ++k)
{
double k_winlength_factor = 1. / (k_high - k_low);
k_winlength_factor -= winlength_factor_baseline;
if (k_winlength_factor <= 0)
continue;
// compute similarity of intensities i k
double similarity_ik;
{
const double int_i = model_map[i].getIntensity();
const double int_k = scene_map[k].getIntensity() * total_intensity_ratio;
similarity_ik = (int_i < int_k) ? int_i / int_k : int_k / int_i;
// weight is inverse proportional to number of elements with similar mz
similarity_ik *= i_winlength_factor;
similarity_ik *= k_winlength_factor;
// VV_(int_i<<' '<<int_k<<' '<<int_similarity_ik);
}
// compute the transformation (i) -> (k)
double shift = model_map[i].getRT() - scene_map[k].getRT();
// hash the images of scaling, rt_low and rt_high into their respective hash tables
shift_hash_.addValue(shift, similarity_ik);
if (do_dump_pairs)
{
dump_pairs_file << i << ' ' << model_map[i].getRT() << ' ' << model_map[i].getMZ() << ' ' << k << ' ' << scene_map[k].getRT() << ' '
<< scene_map[k].getMZ() << ' ' << similarity_ik << ' ' << std::endl;
}
} // k
} // i
}
while (0); // end of hashing (the extra syntax helps with code folding in eclipse!)
setProgress((actual_progress = 30));
///////////////////////////////////////////////////////////////////
// work on shift_hash_
// double shift_low;
// double shift_centroid;
// double shift_high;
// OLD STUFF
// double shift_low;
double shift_centroid;
// double shift_high;
do
{
UInt filtering_stage = 0;
// optionally, dump before filtering
String dump_buckets_filename;
std::ofstream dump_buckets_file;
if (do_dump_buckets)
{
dump_buckets_filename = dump_buckets_basename + "_" + String(dump_buckets_serial);
dump_buckets_file.open(dump_buckets_filename.c_str());
VV_(dump_buckets_filename);
dump_buckets_file << "# shift hash table buckets dump ( scale, height ) : " << dump_buckets_filename << std::endl;
dump_buckets_file << "# unfiltered hash data\n";
for (Size index = 0; index < shift_hash_.getData().size(); ++index)
{
const double image = shift_hash_.index2key(index);
const double height = shift_hash_.getData()[index];
dump_buckets_file << filtering_stage << '\t' << index << '\t' << image << '\t' << height << '\n';
}
dump_buckets_file << '\n';
}
++filtering_stage;
setProgress(++actual_progress);
// apply tophat filter to histogram
MorphologicalFilter morph_filter;
Param morph_filter_param;
morph_filter_param.setValue("struc_elem_unit", "DataPoints");
morph_filter_param.setValue("struc_elem_length", double(struc_elem_length_datapoints));
morph_filter_param.setValue("method", "tophat");
morph_filter.setParameters(morph_filter_param);
LinearInterpolationType_::container_type buffer(shift_hash_.getData().size());
morph_filter.filterRange(shift_hash_.getData().begin(), shift_hash_.getData().end(), buffer.begin());
shift_hash_.getData().swap(buffer);
// optionally, dump after filtering
if (do_dump_buckets)
{
dump_buckets_file << "# tophat filtered hash data\n";
for (Size index = 0; index < shift_hash_.getData().size(); ++index)
{
const double image = shift_hash_.index2key(index);
const double height = shift_hash_.getData()[index];
dump_buckets_file << filtering_stage << '\t' << index << '\t' << image << '\t' << height << '\n';
}
dump_buckets_file << '\n';
}
setProgress(++actual_progress);
++filtering_stage;
// compute freq_cutoff using a fancy criterion to distinguish between the noise level of the histogram and enriched histogram bins
double freq_cutoff_low;
do
{
{
std::copy(shift_hash_.getData().begin(), shift_hash_.getData().end(), buffer.begin());
std::sort(buffer.begin(), buffer.end(), std::greater<double>());
double freq_intercept = shift_hash_.getData().front();
double freq_slope = (shift_hash_.getData().back() - shift_hash_.getData().front()) / double(buffer.size())
/ scaling_histogram_crossing_slope;
if (!freq_slope || !buffer.size())
{
// in fact these conditions are actually impossible, but let's be really sure ;-)
freq_cutoff_low = 0;
}
else
{
Size index = 1; // not 0 (!)
while (buffer[index] >= freq_intercept + freq_slope * double(index))
{
++index;
}
freq_cutoff_low = buffer[--index]; // note that we have index >= 1
}
}
}
while (0);
setProgress(++actual_progress);
// apply freq_cutoff, setting smaller values to zero
for (Size index = 0; index < shift_hash_.getData().size(); ++index)
{
if (shift_hash_.getData()[index] < freq_cutoff_low)
{
shift_hash_.getData()[index] = 0;
}
}
setProgress(++actual_progress);
// optionally, dump after noise filtering using freq_cutoff
if (do_dump_buckets)
{
dump_buckets_file << "# after freq_cutoff, which is: " << freq_cutoff_low << '\n';
for (Size index = 0; index < shift_hash_.getData().size(); ++index)
{
const double image = shift_hash_.index2key(index);
const double height = shift_hash_.getData()[index];
dump_buckets_file << filtering_stage << '\t' << index << '\t' << image << '\t' << height << '\n';
}
dump_buckets_file << '\n';
}
setProgress(++actual_progress);
// iterative cut-off based on mean and stdev - relies upon scaling_cutoff_stdev_multiplier which is a bit hard to set right.
{
Math::BasicStatistics<double> statistics;
std::vector<double>::const_iterator data_begin = shift_hash_.getData().begin();
const Size data_size = shift_hash_.getData().size();
Size data_range_begin = 0;
Size data_range_end = data_size;
for (UInt loop = 0; loop < loops_mean_stdev_cutoff; ++loop) // MAGIC ALERT: number of loops
{
statistics.update(data_begin + data_range_begin, data_begin + data_range_end);
double mean = statistics.mean() + data_range_begin;
double stdev = sqrt(statistics.variance());
data_range_begin = floor(std::max<double>(mean - scaling_cutoff_stdev_multiplier * stdev, 0));
data_range_end = ceil(std::min<double>(mean + scaling_cutoff_stdev_multiplier * stdev + 1, data_size));
const double outside_mean = shift_hash_.index2key(mean);
const double outside_stdev = stdev * shift_hash_.getScale();
// shift_low = (outside_mean - outside_stdev);
shift_centroid = (outside_mean);
// shift_high = (outside_mean + outside_stdev);
if (do_dump_buckets)
{
dump_buckets_file << "# loop: " << loop << " mean: " << outside_mean << " stdev: " << outside_stdev << " (mean-stdev): "
<< outside_mean - outside_stdev << " (mean+stdev): " << outside_mean + outside_stdev
<< " data_range_begin: " << data_range_begin << " data_range_end: "
<< data_range_end << std::endl;
}
}
setProgress(++actual_progress);
}
if (do_dump_buckets)
{
dump_buckets_file << "# EOF" << std::endl;
dump_buckets_file.close();
}
setProgress(80);
}
while (0);
//************************************************************************************
// Estimate transform
// Compute the shifts at the low and high ends by looking at (around) the fullest bins.
double intercept;
#if 1 // yes of course, use centroids for images of rt_low and rt_high
intercept = shift_centroid;
#else // ooh, use maximum bins instead (Note: this is a fossil which would disregard most of the above computations! The code is left here for developers/debugging only.)
const Size rt_low_max_index = std::distance(shift_hash_.getData().begin(),
std::max_element(shift_hash_.getData().begin(), shift_hash_.getData().end()));
intercept = shift_hash_.index2key(rt_low_max_index);
#endif
VV_(intercept);
setProgress(++actual_progress);
// set trafo
{
Param params;
params.setValue("slope", 1.0);
params.setValue("intercept", intercept);
TransformationDescription trafo;
trafo.fitModel("linear", params);
transformation = trafo;
}
setProgress(++actual_progress);
endProgress();
return;
} // run()
