mzintegrationparams.cpp

Go to the documentation of this file.

/* BEGIN software license
 *
 * msXpertSuite - mass spectrometry software suite
 * -----------------------------------------------
 * Copyright(C) 2009,...,2018 Filippo Rusconi
 *
 * http://www.msxpertsuite.org
 *
 * This file is part of the msXpertSuite project.
 *
 * The msXpertSuite project is the successor of the massXpert project. This
 * project now includes various independent modules:
 *
 * - massXpert, model polymer chemistries and simulate mass spectrometric data;
 * - mineXpert, a powerful TIC chromatogram/mass spectrum viewer/miner;
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * END software license
 */
 
 
/////////////////////// StdLib includes
#include <map>
#include <cmath>
 
 
/////////////////////// Qt includes
#include <QDebug>
#include <QString>
#include <QFile>
#include <QDateTime>
#include <QtQml>
 
 
/////////////////////// pappsomspp includes
#include "pappsomspp/core/utils.h"
#include "pappsomspp/core/massspectrum/massspectrum.h"
 
 
/////////////////////// Local includes
#include "mzintegrationparams.h"
 
/*
int mzIntegrationParamsMetaTypeId =
  qRegisterMetaType<pappso::MzIntegrationParams>("pappso::MzIntegrationParams");
int mzIntegrationParamsPtrMetaTypeId =
  qRegisterMetaType<pappso::MzIntegrationParams *>("pappso::MzIntegrationParams *");*/
 
 
namespace pappso
{
 
 
//! Map relating the BinningType to a textual representation
std::map<MzIntegrationParams::BinningType, QString> binningTypeMap{
  {MzIntegrationParams::BinningType::NONE, "NONE"},
  {MzIntegrationParams::BinningType::DATA_BASED, "DATA_BASED"},
  {MzIntegrationParams::BinningType::ARBITRARY, "ARBITRARY"}};
 
MzIntegrationParams::BinningType
getBinningTypeFromString(const QString &text)
{
  std::map<MzIntegrationParams::MzIntegrationParams::BinningType, QString>::const_iterator
    the_iterator_const =
      std::find_if(binningTypeMap.begin(),
                   binningTypeMap.end(),
                   [text](const std::pair<MzIntegrationParams::BinningType, QString> &pair) {
                     return pair.second == text;
                   });
 
  if(the_iterator_const != binningTypeMap.end())
    return the_iterator_const->first;
 
  return MzIntegrationParams::BinningType::NONE;
}
 
 
MzIntegrationParams::MzIntegrationParams(QObject *parent) : QObject(parent)
{
}
 
MzIntegrationParams::MzIntegrationParams(const QString &text, QObject *parent) : QObject(parent)
{
  initialize(text);
}
 
MzIntegrationParams::MzIntegrationParams(double min_mz,
                                         double max_mz,
                                         MzIntegrationParams::BinningType binning_type,
                                         pappso::PrecisionPtr bin_size_model,
                                         int bin_size_divisor,
                                         int decimal_places,
                                         bool remove_zero_val_data_points,
                                         QObject *parent)
  : QObject(parent),
    m_smallestMz(min_mz),
    m_greatestMz(max_mz),
    m_binningType(binning_type),
    m_binSizeModel(bin_size_model),
    m_binSizeDivisor(bin_size_divisor),
    m_decimalPlaces(decimal_places),
    m_removeZeroValDataPoints(remove_zero_val_data_points)
{
  if(m_binSizeModel == nullptr)
    m_binSizeModel = pappso::PrecisionFactory::getPpmInstance(20);
 
  // qDebug() << "MetaObject?" << this->metaObject()->className();
}
 
MzIntegrationParams::~MzIntegrationParams()
{
}
 
MzIntegrationParams *
MzIntegrationParams::clone(QObject *parent) const
{
  MzIntegrationParams *mz_integration_params_p = new MzIntegrationParams(m_smallestMz,
                                                                         m_greatestMz,
                                                                         m_binningType,
                                                                         m_binSizeModel,
                                                                         m_binSizeDivisor,
                                                                         m_decimalPlaces,
                                                                         m_removeZeroValDataPoints,
                                                                         parent);
 
  return mz_integration_params_p;
}
 
MzIntegrationParams::InitializationResult
MzIntegrationParams::initialize(const QString &text)
{
  // qDebug() << "Initializing MzIntegrationParams using text:" << text;
 
  InitializationResult initialization_result = InitializationResult::DEFAULT;
 
  reset();
 
  m_removeZeroValDataPoints = true;
 
  if(text.isEmpty())
    return initialization_result;
 
  // Expected text: "Smallest (first) m/z:294.725158\nGreatest (last) m/z:2055.002453\nDecimal
  // places:-1\nBinning type:2\nBin size model:0.05 dalton\nBin size divisor:1\nRemove 0-val data
  // points:1\n"
 
  // In order to consider that the parameters were correctly read, we need
  // some of the members to effectively be set from the settings values.
 
  bool binning_type_set            = false;
  bool decimal_places_set          = false;
  bool bin_size_model_set          = false;
  bool bin_size_divisor_set        = false;
  bool remove_zero_data_points_set = false;
 
  QStringList string_list = text.split("\n");
 
  for(int iter = 0; iter < string_list.size(); ++iter)
    {
      QString iter_string = string_list.at(iter);
 
      // qDebug() << "Iterating in string:" << iter_string;
 
      if(iter_string.contains("Binning type:"))
        {
          m_binningType    = getBinningTypeFromString(iter_string.split(':').last());
          binning_type_set = true;
        }
      else if(iter_string.contains("Bin size model:"))
        {
          m_binSizeModel     = PrecisionFactory::fromString(iter_string.split(':').last());
          bin_size_model_set = true;
        }
      else if(iter_string.contains("Bin size divisor:"))
        {
          m_binSizeDivisor     = iter_string.split(':').last().toInt();
          bin_size_divisor_set = true;
        }
      else if(iter_string.contains("Decimal places:"))
        {
          m_decimalPlaces    = iter_string.split(':').last().toInt();
          decimal_places_set = true;
        }
      else if(iter_string.contains("Remove 0-val data points:"))
        {
          remove_zero_data_points_set = true;
          m_removeZeroValDataPoints   = iter_string.split(':').last().toInt();
        }
    }
 
  // qDebug() << "At this point the initialization is done and this"
  //             " MzIntegrationParams instance is: "
  //          << toString();
 
  if(binning_type_set)
    initialization_result |= InitializationResult::BINNING_TYPE;
  if(bin_size_model_set)
    initialization_result |= InitializationResult::BIN_SIZE_MODEL;
  if(bin_size_divisor_set)
    initialization_result |= InitializationResult::BIN_SIZE_DIVISOR;
  if(decimal_places_set)
    initialization_result |= InitializationResult::DECIMAL_PLACES;
 
  if(remove_zero_data_points_set)
    initialization_result |= InitializationResult::REMOVE_ZERO_DATA_POINTS;
 
  return initialization_result;
}
 
void
MzIntegrationParams::initialize(double min_mz,
                                double max_mz,
                                MzIntegrationParams::BinningType binning_type,
                                pappso::PrecisionPtr bin_size_model,
                                int bin_size_divisor,
                                int decimal_places,
                                bool remove_zero_val_data_points,
                                QObject *parent)
{
  m_smallestMz              = min_mz;
  m_greatestMz              = max_mz;
  m_binningType             = binning_type;
  m_binSizeModel            = bin_size_model;
  m_binSizeDivisor          = bin_size_divisor;
  m_decimalPlaces           = decimal_places;
  m_removeZeroValDataPoints = remove_zero_val_data_points;
 
  setParent(parent);
}
 
void
MzIntegrationParams::initialize(const MzIntegrationParams &other, QObject *parent)
{
  m_smallestMz              = other.m_smallestMz;
  m_greatestMz              = other.m_greatestMz;
  m_binningType             = other.m_binningType;
  m_binSizeModel            = other.m_binSizeModel;
  m_binSizeDivisor          = other.m_binSizeDivisor;
  m_decimalPlaces           = other.m_decimalPlaces;
  m_removeZeroValDataPoints = other.m_removeZeroValDataPoints;
 
  setParent(parent);
}
 
// Initialize this MzIntegrationParams using other but only for members that were
// effectively set upon reading from a text string (see initialize (QString)).
void
MzIntegrationParams::initialize(MzIntegrationParams &other,
                                InitializationResult initialization_results)
{
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BINNING_TYPE))
    m_binningType = other.m_binningType;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BIN_SIZE_MODEL))
    m_binSizeModel = other.m_binSizeModel;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BIN_SIZE_DIVISOR))
    m_binSizeDivisor = other.m_binSizeDivisor;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::DECIMAL_PLACES))
    m_decimalPlaces = other.m_decimalPlaces;
}
 
void
MzIntegrationParams::setSmallestMz(double value)
{
  if(m_smallestMz != value)
    m_smallestMz = value;
 
  emit smallestMzChanged();
}
 
 
void
MzIntegrationParams::updateSmallestMz(double value)
{
  if(value == m_smallestMz)
    return;
 
  m_smallestMz = value;
  emit smallestMzChanged();
}
 
 
double
MzIntegrationParams::getSmallestMz() const
{
  return m_smallestMz;
}
 
 
void
MzIntegrationParams::setGreatestMz(double value)
{
  if(m_greatestMz == value)
    return;
 
  m_greatestMz = value;
  emit greatestMzChanged();
}
 
 
void
MzIntegrationParams::updateGreatestMz(double value)
{
  if(value > m_greatestMz)
    {
      m_greatestMz = value;
      emit greatestMzChanged();
    }
}
 
 
double
MzIntegrationParams::getGreatestMz() const
{
  return m_greatestMz;
}
 
void
MzIntegrationParams::setMzValues(double smallest, double greatest)
{
  setSmallestMz(smallest);
  setGreatestMz(greatest);
}
 
void
MzIntegrationParams::setBinningType(MzIntegrationParams::BinningType binning_type)
{
  if(m_binningType == binning_type)
    return;
 
  m_binningType = binning_type;
  return binningTypeChanged();
}
 
 
MzIntegrationParams::BinningType
MzIntegrationParams::getBinningType() const
{
  return m_binningType;
}
 
 
int
MzIntegrationParams::getDecimalPlaces() const
{
  return m_decimalPlaces;
}
 
void
MzIntegrationParams::setBinSizeModel(pappso::PrecisionPtr bin_size_model_p)
{
  if(m_binSizeModel == bin_size_model_p)
    return;
 
  m_binSizeModel = bin_size_model_p;
 
  if(m_binSizeModel == nullptr)
    m_binSizeModel = pappso::PrecisionFactory::getResInstance(40000);
}
 
pappso::PrecisionPtr
MzIntegrationParams::getBinSizeModel() const
{
  return m_binSizeModel;
}
 
void
MzIntegrationParams::setBinSizeDivisor(int divisor)
{
  if(m_binSizeDivisor == divisor)
    return;
 
  m_binSizeDivisor = divisor;
  emit binSizeDivisorChanged();
}
 
int
MzIntegrationParams::getBinSizeDivisor() const
{
  return m_binSizeDivisor;
}
 
void
MzIntegrationParams::setDecimalPlaces(int decimal_places)
{
  if(m_decimalPlaces == decimal_places)
    return;
 
  m_decimalPlaces = decimal_places;
  emit decimalPlacesChanged();
}
 
void
MzIntegrationParams::setRemoveZeroValDataPoints(bool removeOrNot)
{
  if(m_removeZeroValDataPoints == removeOrNot)
    return;
 
  m_removeZeroValDataPoints = removeOrNot;
  emit removeZeroValDataPointsChanged();
}
 
 
bool
MzIntegrationParams::isRemoveZeroValDataPoints() const
{
  return m_removeZeroValDataPoints;
}
 
 
//! Reset the instance to default values.
void
MzIntegrationParams::reset()
{
  m_smallestMz = std::numeric_limits<double>::max();
  m_greatestMz = std::numeric_limits<double>::min();
 
  m_binningType    = BinningType::ARBITRARY;
  m_binSizeModel   = pappso::PrecisionFactory::getResInstance(40000);
  m_binSizeDivisor = 1;
  m_decimalPlaces  = -1;
 
  m_removeZeroValDataPoints = true;
 
  emit wasReset();
}
 
 
bool
MzIntegrationParams::isValid() const
{
  int errors = 0;
 
  if(m_binningType != MzIntegrationParams::BinningType::NONE)
    {
      // qDebug() << "m_smallestMz:" << m_smallestMz;
      // qDebug() << "smallest is max:" << (m_smallestMz ==
      // std::numeric_limits<double>::max());
      errors += (m_smallestMz == std::numeric_limits<double>::max() ? 1 : 0);
 
      // qDebug() << "m_greatestMz:" << m_greatestMz;
      // qDebug() << "greatest is min:" << (m_greatestMz ==
      // std::numeric_limits<double>::min());
      errors += (m_greatestMz == std::numeric_limits<double>::min() ? 1 : 0);
    }
 
  if(errors)
    {
      qCritical() << "The m/z integration parameters are invalid.";
    }
 
  return !errors;
}
 
 
bool
MzIntegrationParams::hasValidMzRange() const
{
  return (m_smallestMz < std::numeric_limits<double>::max()) &&
         (m_greatestMz >= std::numeric_limits<double>::min());
}
 
 
std::vector<double>
MzIntegrationParams::createBins()
{
 
  // qDebug() << "mp_precision:" << mp_precision->toString();
 
  std::vector<double> bins;
 
  if(m_binningType == MzIntegrationParams::BinningType::NONE)
    {
      // If no binning is to be performed, fine.
      return bins;
    }
  else if(m_binningType == MzIntegrationParams::BinningType::ARBITRARY)
    {
      // Use only data in the MzIntegrationParams member data.
      return createArbitraryBins();
    }
  else if(m_binningType == MzIntegrationParams::BinningType::DATA_BASED)
    {
      // qDebug();
 
      qFatal("Programming error. This kind of binning is not supported.");
    }
 
  return bins;
}
 
 
std::vector<double>
MzIntegrationParams::createBins(pappso::MassSpectrumCstSPtr mass_spectrum_csp)
{
 
  // qDebug();
 
  std::vector<double> bins;
 
  if(m_binningType == MzIntegrationParams::BinningType::NONE)
    {
      // If no binning is to be performed, fine.
      return bins;
    }
  else if(m_binningType == MzIntegrationParams::BinningType::ARBITRARY)
    {
      // Use only data in the MzIntegrationParams member data.
      return createArbitraryBins();
    }
  else if(m_binningType == MzIntegrationParams::BinningType::DATA_BASED)
    {
      // qDebug();
 
      // Use the first spectrum to perform the data-based bins
 
      return createDataBasedBins(mass_spectrum_csp);
    }
 
  return bins;
}
 
 
std::vector<double>
MzIntegrationParams::createArbitraryBins()
{
  // Now starts the tricky stuff. Depending on the binning size model, we need to take diverse
  // actions.
 
  if(!isValid())
    qFatal() << "Programming error. The MzIntegrationParams::BinningLogic is not valid, cannot "
                "create bins.";
 
  qDebug() << "Binning logic:" << toString();
 
  double min_mz = m_smallestMz;
  double max_mz = m_greatestMz;
 
  qDebug() << "m_smallestMz:" << m_smallestMz << "m_greatestMz:" << m_greatestMz;
 
  double bin_size;
 
  if(m_binSizeModel->unit() == Enums::PrecisionUnit::res)
    {
      double resolution_based_bin_size = m_binSizeModel->delta(min_mz);
      bin_size                         = resolution_based_bin_size / m_binSizeDivisor;
 
      // qDebug() << "With res-based bin size, the uncorrected bin size:"
      //<< resolution_based_bin_size
      //<< "and the final binSize:" << binSize;
    }
  else
    bin_size = m_binSizeModel->delta(min_mz);
 
  // qDebug() << QString::asprintf(
  //"binSize is the precision delta for min_mz: %.6f\n", binSize);
 
  // Only compute the decimal places if they were not configured already.
  if(m_decimalPlaces == -1)
    {
      // qDebug() << "Now checking how many decimal places are needed.";
 
      // We want as many decimal places as there are 0s between the integral
      // part of the double and the first non-0 cipher.  For example, if
      // binSize is 0.004, zero decimals is 2 and m_decimalPlaces is set to 3,
      // because we want decimals up to 4 included.
 
      m_decimalPlaces = pappso::Utils::zeroDecimalsInValue(bin_size) + 1;
 
      // qDebug() << "With binSize" << binSize
      //<< " m_decimalPlaces was computed to be:" << m_decimalPlaces;
    }
  // else
  // qDebug() << "m_decimalPlaces: " << m_decimalPlaces;
 
  // Now that we have defined the value of m_decimalPlaces, let's use that
  // value.
 
  double first_mz =
    ceil((min_mz * std::pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
  double last_mz = ceil((max_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
  // qDebug() << "After having accounted for the decimals, new min/max values:"
  //<< QString::asprintf("Very first data point: %.6f\n", first_mz)
  //<< QString::asprintf("Very last data point to reach: %.6f\n",
  // last_mz);
 
  // Instanciate the vector of mz double_s that we'll feed with the bins.
 
  std::vector<double> bins;
 
  // Store that very first value for later use in the loop.
  // The bins are notking more than:
  //
  // 1. The first mz (that is the smallest mz value found in all the spectra
  // 2. A sequence of mz values corresponding to that first mz value
  // incremented by the bin size.
 
  // Seed the root of the bin vector with the first mz value rounded above as
  // requested.
  double previous_mz_bin = first_mz;
 
  bins.push_back(previous_mz_bin);
 
  // Now continue adding mz values until we have reached the end of the
  // spectrum, that is the max_mz value, as converted using the decimals to
  // last_mz.
 
  // debugCount value used below for debugging purposes.
  // int debugCount = 0;
 
  while(previous_mz_bin <= last_mz)
    {
 
      // qDebug() << "Now starting the bin creation loop.";
 
      // Calculate dynamically the precision delta according to the current mz
      // value.
 
      // double precision_delta = mp_precision->delta(previous_mz_bin);
      // qDebug() << "precision_delta: " << precision_delta;
 
      // In certain circumstances, the bin size is not enough to properly render
      // hyper-high resolution data (like the theoretical isotopic cluster data
      // generated in silico). In that case, the bin size, computed using the
      // precision object, is divided by the m_binSizeDivisor, which normally is
      // set to 1 as the default, that is, it has no effect.
 
      double current_mz;
 
      if(m_binSizeModel->unit() == Enums::PrecisionUnit::res)
        {
          current_mz =
            previous_mz_bin + (m_binSizeModel->delta(previous_mz_bin) / m_binSizeDivisor);
        }
      else
        {
          current_mz = previous_mz_bin + m_binSizeModel->delta(previous_mz_bin);
        }
 
      // qDebug() << QString::asprintf(
      //"previous_mzBin: %.6f and current_mz: %.6f\n",
      // previous_mz_bin,
      // current_mz);
 
      // Now apply on the obtained mz value the decimals that were either set
      // or computed earlier.
 
      double current_rounded_mz =
        ceil((current_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      // qDebug() << QString::asprintf(
      //"current_mz: %.6f and current_rounded_mz: %.6f and previous_mzBin "
      //": % .6f\n ",
      // current_mz,
      // current_rounded_mz,
      // previous_mz_bin);
 
      // If rounding makes the new value identical to the previous one, then
      // that means that we need to decrease roughness.
 
      if(current_rounded_mz == previous_mz_bin)
        {
          ++m_decimalPlaces;
 
          current_rounded_mz =
            ceil((current_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
          // qDebug().noquote()
          //<< "Had to increment decimal places by one while creating the bins "
          //"in MzIntegrationParams::BinningType::ARBITRARY mode..";
        }
 
      bins.push_back(current_rounded_mz);
 
      // Use the local_mz value for the storage of the previous mz bin.
      previous_mz_bin = current_rounded_mz;
    }
 
 
#if 0
 
  QString fileName = "/tmp/massSpecArbitraryBins.txt-at-" +
                     QDateTime::currentDateTime().toString("yyyyMMdd-HH-mm-ss");
 
  qDebug() << "Writing the list of bins setup in the "
              "mass spectrum in file "
           << fileName;
 
  QFile file(fileName);
  file.open(QIODevice::WriteOnly);
 
  QTextStream fileStream(&file);
 
  for(auto &&bin : bins)
    fileStream << QString("%1\n").arg(bin, 0, 'f', 10);
 
  fileStream.flush();
  file.close();
 
#endif
 
  // qDebug() << "Prepared bins with " << bins.size() << "elements."
  //<< "starting with mz" << bins.front() << "ending with mz"
  //<< bins.back();
 
  return bins;
}
 
 
std::vector<double>
MzIntegrationParams::createDataBasedBins(pappso::MassSpectrumCstSPtr mass_spectrum_csp)
{
  // qDebug();
 
  // The bins in *this mass spectrum must be calculated starting from the
  // data in the mass_spectrum_csp parameter.
 
  // Instanciate the vector of mz double_s that we'll feed with the bins.
 
  std::vector<double> bins;
 
  if(mass_spectrum_csp->size() < 2)
    return bins;
 
  // Make sure the spectrum is sorted, as this functions takes for granted
  // that the DataPoint instances are sorted in ascending x (== mz) value
  // order.
  pappso::MassSpectrum local_mass_spectrum = *mass_spectrum_csp;
  local_mass_spectrum.sortMz();
 
  double min_mz = m_smallestMz;
 
  // qDebug() << "The min_mz:" << min_mz;
 
  if(m_decimalPlaces != -1)
    min_mz = ceil((min_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
 
  // Two values for the definition of a MassSpectrumBin.
 
  // The first value of the mz range that defines the bin. This value is part
  // of the bin.
  double start_mz_in = min_mz;
 
  // The second value of the mz range that defines the bin. This value is
  // *not* part of the bin.
  double end_mz_out;
 
  std::vector<pappso::DataPoint>::const_iterator it = local_mass_spectrum.begin();
 
  double prev_mz = it->x;
 
  if(m_decimalPlaces != -1)
    prev_mz = ceil((prev_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
  ++it;
 
  while(it != local_mass_spectrum.end())
    {
      double next_mz = it->x;
 
      if(m_decimalPlaces != -1)
        next_mz = ceil((next_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      double step = next_mz - prev_mz;
      end_mz_out  = start_mz_in + step;
 
      if(m_decimalPlaces != -1)
        end_mz_out =
          ceil((end_mz_out * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      // The data point that is crafted has a 0 y-value. The binning must
      // indeed not create artificial intensity data.
 
      // qDebug() << "Pushing back bin:" << start_mz_in << end_mz_out;
 
      bins.push_back(start_mz_in);
 
      // Prepare next bin
      start_mz_in = end_mz_out;
 
      // Update prev_mz to be the current one for next iteration.
      prev_mz = next_mz;
 
      // Now got the next DataPoint instance.
      ++it;
    }
 
#if 0
 
  QString fileName = "/tmp/massSpecDataBasedBins.txt";
 
  qDebug() << "Writing the list of bins setup in the "
              "mass spectrum in file "
           << fileName;
 
  QFile file(fileName);
  file.open(QIODevice::WriteOnly);
 
  QTextStream fileStream(&file);
 
  for(auto &&bin : m_bins)
    fileStream << QString("[%1-%2]\n")
                    .arg(bin.startMzIn, 0, 'f', 10)
                    .arg(bin.endMzOut, 0, 'f', 10);
 
  fileStream.flush();
  file.close();
 
  qDebug() << "elements."
           << "starting with mz" << m_bins.front().startMzIn << "ending with mz"
           << m_bins.back().endMzOut;
 
#endif
 
  return bins;
}
 
// This is for documentation, not for outputting the string used in the
// settings that are saved on disk.
QString
MzIntegrationParams::toString(int offset, const QString &spacer) const
{
  // The space-containing string that reflects the offset at which
  // new text lines should be added to start with.
  QString offset_lead;
 
  for(int iter = 0; iter < offset; ++iter)
    offset_lead += spacer;
 
  QString text = offset_lead;
  text += "m/z integration parameters:\n";
 
  QString new_lead = QString("%1%2").arg(offset_lead).arg(spacer);
 
  text += new_lead;
  if(m_smallestMz != std::numeric_limits<double>::max())
    text.append(QString::asprintf("Smallest (first) m/z: %.6f\n", m_smallestMz));
 
  text += new_lead;
  if(m_greatestMz != std::numeric_limits<double>::min())
    text.append(QString::asprintf("Greatest (last) m/z: %.6f\n", m_greatestMz));
 
  text += new_lead;
  text +=
    QString("Remove 0-val data points: %1\n").arg(m_removeZeroValDataPoints ? "true" : "false");
 
  text += new_lead;
  text.append("Binning logic:\n");
 
  new_lead += spacer;
 
  text += new_lead;
  text.append(QString("Binning type:%1\n").arg(::pappso::binningTypeMap[m_binningType]));
 
  text += new_lead;
  text.append(QString("Bin size model: %1\n").arg(m_binSizeModel->toString()));
 
  text += new_lead;
  text.append(QString("Bin size divisor: %2\n").arg(m_binSizeDivisor));
 
  text += new_lead;
  text.append(QString("Decimal places: %1\n").arg(m_decimalPlaces));
 
  return text;
}
 
// This version is used to craft the string that enables the initialization.
QString
MzIntegrationParams::toString() const
{
  QString text;
 
  // In the string for saving settings, we do not ouput the m/z values.
  text.append(QString("Binning type:%1\n").arg(::pappso::binningTypeMap[m_binningType]));
  text.append(QString("Bin size model: %1\n").arg(m_binSizeModel->toString()));
  text.append(QString("Bin size divisor: %2\n").arg(m_binSizeDivisor));
  text.append(QString("Decimal places:%1\n").arg(m_decimalPlaces));
  text.append(QString("Remove 0-val data points:%1\n").arg(m_removeZeroValDataPoints));
 
  // qDebug().noquote() << "Returning text:\n" << text;
 
  return text;
}
 
 
void
MzIntegrationParams::registerJsConstructor(QJSEngine *engine)
{
  qDebug() << "registerJsConstructor for MzIntegrationParams to QJSEngine.";
 
  if(!engine)
    {
      qWarning() << "Cannot register class: engine is null";
      return;
    }
 
  QJSValue enumObject;
 
  enumObject = engine->newObject();
  enumObject.setProperty("none", static_cast<int>(pappso::MzIntegrationParams::BinningType::NONE));
  enumObject.setProperty("dataBased",
                         static_cast<int>(pappso::MzIntegrationParams::BinningType::DATA_BASED));
  enumObject.setProperty("arbitrary",
                         static_cast<int>(pappso::MzIntegrationParams::BinningType::ARBITRARY));
  engine->globalObject().setProperty("BinningType", enumObject);
 
  enumObject = engine->newObject();
  enumObject.setProperty(
    "default", static_cast<int>(pappso::MzIntegrationParams::InitializationResult::DEFAULT));
  enumObject.setProperty(
    "fromSettingsBinSizeModelPartial",
    static_cast<int>(pappso::MzIntegrationParams::InitializationResult::BINNING_LOGIC_PARTIAL));
  enumObject.setProperty(
    "fromSettingsBinSizeModelFull",
    static_cast<int>(pappso::MzIntegrationParams::InitializationResult::BINNING_LOGIC_FULL));
  enumObject.setProperty("fromSettingsFull",
                         static_cast<int>(pappso::MzIntegrationParams::InitializationResult::FULL));
  engine->globalObject().setProperty("InitializationResult", enumObject);
 
  // Register the meta object as a constructor
  QJSValue jsMetaObject = engine->newQMetaObject(&MzIntegrationParams::staticMetaObject);
  engine->globalObject().setProperty("MzIntegrationParams", jsMetaObject);
}
 
} // namespace pappso