qavrgacquisitiondata.cpp

Go to the documentation of this file.

#include "qavrgacquisitiondata.h"

#include "qavrgsettings.h"
#include "qavrgfitter.h"

#include <QFile>
#include <stdio.h>

QavrgAcquisitionData::QavrgAcquisitionData(QavrgAcquisitionThread */*acq*/, QavrgApplication */*app*/, QObject *parent)
  : QavrgAcquisitionParms(parent),
    m_AcquireCancel(0)
{
}

QavrgAcquisitionData::~QavrgAcquisitionData()
{
}

//QVector< QVector<double> > QavrgAcquisitionData::get_RawData()
//{
//  QMutexLocker lock(&m_RawDataMutex);
//
//  return m_RawData;
//}
//
QVector<double> QavrgAcquisitionData::get_RawData(int chan, int start, int nbins)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);
//
//  return m_RawData.value(chan).mid(start,nbins);

  return fitter(chan) -> get_RawData(start, nbins);
}

QVector<double> QavrgAcquisitionData::get_RawData(int chan)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);
//
//  return m_RawData.value(chan);

  return fitter(chan) -> get_RawData();
}

double QavrgAcquisitionData::get_RawData(int chan, int bin)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_RawData(bin);
}

void QavrgAcquisitionData::setReferenceData()
{
  int nchan = get_NChannels();

  for (int i=0; i<nchan; i++) {
    fitter(i) -> setReferenceData();
  }

  saveReferenceData();

  emit new_ReferenceData();
}

void QavrgAcquisitionData::setDarkData()
{
  int nchan = get_NChannels();

  for (int i=0; i<nchan; i++) {
    fitter(i) -> setDarkData();
  }

  saveDarkData();

  emit new_DarkData();
}

//int QavrgAcquisitionData::referenceAvailable() const
//{
//  return m_ReferenceAvailable;
//}
//
//int QavrgAcquisitionData::darkAvailable() const
//{
//  return m_DarkAvailable;
//}

//QVector< QVector<double> > QavrgAcquisitionData::get_ReferenceData()
//{
//  QMutexLocker lock(&m_ReferenceDataMutex);
//
//  return m_ReferenceData;
//}
//
QVector<double> QavrgAcquisitionData::get_ReferenceData(int chan, int start, int nbins)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_ReferenceData(start,nbins);
}

QVector<double> QavrgAcquisitionData::get_ReferenceData(int chan)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_ReferenceData();
}

double QavrgAcquisitionData::get_ReferenceData(int chan, int bin)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_ReferenceData(bin);
}

//QVector< QVector<double> > QavrgAcquisitionData::get_DarkData()
//{
//  QMutexLocker lock(&m_AcquisitionDataMutex);
//
//  return m_DarkData;
//}

QVector<double> QavrgAcquisitionData::get_DarkData(int chan, int start, int nbins)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_DarkData(start,nbins);
}

QVector<double> QavrgAcquisitionData::get_DarkData(int chan)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_DarkData();
}

double QavrgAcquisitionData::get_DarkData(int chan, int bin)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_DarkData(bin);
}

//QVector< QVector<double> > QavrgAcquisitionData::get_FitData()
//{
//  QMutexLocker lock(&m_FitDataMutex);
//
//  return m_FitData;
//}

QVector<double> QavrgAcquisitionData::get_FitData(int chan, int start, int nbins)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_FitData(start,nbins);
}

QVector<double> QavrgAcquisitionData::get_FitData(int chan)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_FitData();
}

double QavrgAcquisitionData::get_FitData(int chan, int bin)
{
  QMutexLocker lock(&m_AcquisitionDataMutex);

  return fitter(chan) -> get_FitData(bin);
}

//void QavrgAcquisitionData::set_FitData(int chan, int bin, double value)
//{
//  QMutexLocker lock(&m_AcquisitionDataMutex);
//
//  fitter(chan) -> set_FitData(bin, value);
//}
//
//void QavrgAcquisitionData::set_FitData(int chan, QVector<double> value)
//{
//  QMutexLocker lock(&m_AcquisitionDataMutex);
//
//  fitter(chan) -> set_FitData(value);
//}

//QString QavrgAcquisitionData::referenceDataPath(int chan)
//{
//  return QavrgSettings::settingsDirectory().filePath(tr("ref%1").arg(chan));
//}

void QavrgAcquisitionData::loadReferenceData()
{
  int nchan = get_NChannels();

  for (int i = 0; i<nchan; i++) {
    fitter(i) -> loadReferenceData();
  }
}

void QavrgAcquisitionData::saveReferenceData()
{
  int nchan = get_NChannels();

  for (int i = 0; i<nchan; i++) {
    fitter(i) -> saveReferenceData();
  }
}


void QavrgAcquisitionData::loadDarkData()
{
  int nchan = get_NChannels();

  for (int i = 0; i<nchan; i++) {
    fitter(i) -> loadDarkData();
  }
}

void QavrgAcquisitionData::saveDarkData()
{
  int nchan = get_NChannels();

  for (int i = 0; i<nchan; i++) {
    fitter(i) -> saveDarkData();
  }
}

//void QavrgAcquisitionData::setReferenceAvailable(int t)
//{
//  m_ReferenceAvailable = t;
//}
//
//void QavrgAcquisitionData::setDarkAvailable(int t)
//{
//  m_DarkAvailable = t;
//}

//void QavrgAcquisitionData::readData(QString loadName)
//{
//  QMutexLocker lock(&m_RawDataMutex);
//
//  if (!loadName.isNull()) {
//    double val;
//    long n;
//
//    QFile file(loadName);
//    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) return;
//
//    int ncols=0, nrows=0;
//
//    QByteArray buffer(20000, 0);
//
//    while (!file.atEnd()) {
//      n = file.readLine(buffer.data(), buffer.count());
//
//      char* p=buffer.data();
//      int nf = 0;
//      while(1) {
//        char *endp;
//        val = strtod(p, &endp);
//        if (p != endp) {
//          nf++;
//          p = endp;
//        } else {
//          break;
//        }
//      }
//
//      if (nf) {
//        nrows ++;
//      }
//
//      if (nf>ncols) {
//        ncols = nf;
//      }
//    }
//
//    printf("%d rows, %d cols\n", nrows, ncols);
//
//    file.seek(0);
//
//    m_RawData.resize(ncols);
//    for (int i=0; i<ncols; i++) { // skip column 0
//      m_RawData[i].resize(nrows);
//    }
//
//    for (int r=0; r<nrows; r++) {
//      n = file.readLine(buffer.data(), buffer.count());
//
//      char* p=buffer.data();
//
//      for (int c=0; c<ncols; c++) {
//        char *endp;
//        val = strtod(p, &endp);
//        if (p != endp) {
//          m_RawData[c][r] = val;
//          p = endp;
//        } else {
//          break;
//        }
//      }
//    }
//
//    emit new_RawData();
//  }
//}
//
//void QavrgAcquisitionData::writeData(QString &saveName)
//{
//  QMutexLocker lock(&m_RawDataMutex);
//
//  if (!saveName.isNull()) {
//    FILE *f = fopen(qPrintable(saveName),"w");
//
//    int nacq = m_RawData.count();
//    int n    = m_RawData[0].count();
//
//    for (int r=0; r<n; r++) {
//      fprintf(f, "%d\t", r);
//
//      for (int i=0; i<nacq*2; i++) {
//        fprintf(f, "%g\t", m_RawData[i][r]);
//      }
//      fprintf(f,"\n");
//    }
//
//    fclose(f);
//  }
//}
//
//QVector< QFuture<void> >   QavrgAcquisitionData::futures() const
//{
//  QMutexLocker lock(&m_Mutex);
//
//  return m_Futures;
//}