tempo-plotter Changeset - cd99f9b81da2 · protofusion repositories

Changeset - cd99f9b81da2

Parent rev.

Child rev.

[Not reviewed]

gain-offset

0 3 0

Hasan Yavuz ÖZDERYA - 7 years ago 2018-07-08 05:50:12
hy@ozderya.net

preliminary implementation of gain and offset

3 files changed with 40 insertions and 2 deletions:

src/channelinfomodel.cpp

src/channelinfomodel.h

src/stream.cpp

0 comments (0 inline, 0 general)

src/channelinfomodel.cpp

➞

Show inline comments

 /*
   Copyright © 2018 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot 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.
   serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "channelinfomodel.h"
 #include "setting_defines.h"
 #define NUMOF_COLORS  (32)
 const QColor colors[NUMOF_COLORS] =
+{
     QColor("#ff0056"),
     QColor("#7e2dd2"),
     QColor("#00ae7e"),
     QColor("#fe8900"),
     QColor("#ff937e"),
     QColor("#6a826c"),
     QColor("#ff029d"),
     QColor("#00b917"),
     QColor("#7a4782"),
     QColor("#85a900"),
     QColor("#a42400"),
     QColor("#683d3b"),
     QColor("#bdc6ff"),
     QColor("#263400"),
     QColor("#bdd393"),
     QColor("#d5ff00"),
     QColor("#9e008e"),
     QColor("#001544"),
     QColor("#c28c9f"),
     QColor("#ff74a3"),
     QColor("#01d0ff"),
     QColor("#004754"),
     QColor("#e56ffe"),
     QColor("#788231"),
     QColor("#0e4ca1"),
     QColor("#91d0cb"),
     QColor("#be9970"),
     QColor("#968ae8"),
     QColor("#bb8800"),
     QColor("#43002c"),
     QColor("#deff74"),
     QColor("#00ffc6")
 };
 ChannelInfoModel::ChannelInfoModel(unsigned numberOfChannels, QObject* parent) :
     QAbstractTableModel(parent)
+{
     _numOfChannels = 0;
     setNumOfChannels(numberOfChannels);
+}
 ChannelInfoModel::ChannelInfoModel(const ChannelInfoModel& other) :
     ChannelInfoModel(other.rowCount(), other.parent())
+{
     for (int i = 0; i < other.rowCount(); i++)
+    {
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::EditRole),
                 Qt::EditRole);
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::ForegroundRole),
                 Qt::ForegroundRole);
         setData(index(i, COLUMN_VISIBILITY),
                 other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),
                 Qt::CheckStateRole);
         // TODO: gain and offset
+    }
+}
 ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :
     ChannelInfoModel(channelNames.length(), NULL)
+{
     for (int i = 0; i < channelNames.length(); i++)
+    {
         setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);
+    }
+}
 ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)
+{
     name = tr("Channel %1").arg(index + 1);
     visibility = true;
     color = colors[index % NUMOF_COLORS];
     gain = 1.0;
     offset = 0.0;
     gainEn = false;
     offsetEn = false;
+}
 QString ChannelInfoModel::name(unsigned i) const
+{
     return infos[i].name;
+}
 QColor ChannelInfoModel::color(unsigned i) const
+{
     return infos[i].color;
+}
 bool ChannelInfoModel::isVisible(unsigned i) const
+{
     return infos[i].visibility;
+}
 bool ChannelInfoModel::gainEn (unsigned i) const
+{
     return infos[i].gainEn;
+}
 double ChannelInfoModel::gain (unsigned i) const
+{
     return infos[i].gain;
+}
 bool ChannelInfoModel::offsetEn (unsigned i) const
+{
     return infos[i].offsetEn;
+}
 double ChannelInfoModel::offset (unsigned i) const
+{
     return infos[i].offset;
+}
 QStringList ChannelInfoModel::channelNames() const
+{
     QStringList r;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         r << name(ci);
+    }
     return r;
+}
 int ChannelInfoModel::rowCount(const QModelIndex &parent) const
+{
     return _numOfChannels;
+}
 int ChannelInfoModel::columnCount(const QModelIndex & parent) const
+{
     return COLUMN_COUNT;
+}
 Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const
+{
     if (index.column() == COLUMN_NAME)
+    {
         return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     else if (index.column() == COLUMN_GAIN || index.column() == COLUMN_OFFSET)
+    {
         return Qt::ItemIsEditable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     return Qt::NoItemFlags;
+}
 QVariant ChannelInfoModel::data(const QModelIndex &index, int role) const
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return QVariant();
+    }
     auto &info = infos[index.row()];
     // get color
     if (role == Qt::ForegroundRole)
+    {
         return info.color;
+    }
     // name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(info.name);
+        }
     } // visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool visible = info.visibility;
             return visible ? Qt::Checked : Qt::Unchecked;
+        }
     } // gain
     else if (index.column() == COLUMN_GAIN)
+    {
         if (role == Qt::CheckStateRole)
+        {
             return info.gainEn ? Qt::Checked : Qt::Unchecked;
+        }
         else if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(info.gain);
+        }
     } // offset
     else if (index.column() == COLUMN_OFFSET)
+    {
         if (role == Qt::CheckStateRole)
+        {
             return info.offsetEn ? Qt::Checked : Qt::Unchecked;
+        }
         else if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(info.offset);
+        }
+    }
     return QVariant();
+}
 QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
     if (orientation == Qt::Horizontal)
+    {
         if (role == Qt::DisplayRole)
+        {
             if (section == COLUMN_NAME)
+            {
                 return tr("Channel");
+            }
             else if (section == COLUMN_VISIBILITY)
+            {
                 return tr("Visible");
+            }
             else if (section == COLUMN_GAIN)
+            {
                 return tr("Gain");
+            }
             else if (section == COLUMN_OFFSET)
+            {
                 return tr("Offset");
+            }
+        }
+    }
     else                        // vertical
+    {
         if (section < (int) _numOfChannels && role == Qt::DisplayRole)
+        {
             return QString::number(section + 1);
+        }
+    }
     return QVariant();
+}
 bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return false;
+    }
     auto &info = infos[index.row()];
     // set color
     if (role == Qt::ForegroundRole)
+    {
         info.color = value.value<QColor>();
         emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));
         return true;
+    }
     // set name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             info.name = value.toString();
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
     } // set visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             info.visibility = checked;
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
+    }
     else if (index.column() == COLUMN_GAIN)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             info.gain = value.toDouble();
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
         else if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             info.gainEn = checked;
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
+    }
     else if (index.column() == COLUMN_OFFSET)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             info.offset = value.toDouble();
             emit dataChanged(index, index, QVector<int>({role}));
             return true;

src/channelinfomodel.h

➞

Show inline comments

 /*
   Copyright © 2018 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot 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.
   serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef CHANNELINFOMODEL_H
 #define CHANNELINFOMODEL_H
 #include <QAbstractTableModel>
 #include <QColor>
 #include <QSettings>
 #include <QStringList>
 class ChannelInfoModel : public QAbstractTableModel
+{
     Q_OBJECT
 public:
     enum ChannelInfoColumn
+    {
         COLUMN_NAME = 0,
         COLUMN_VISIBILITY,
         COLUMN_GAIN,
         COLUMN_OFFSET,
         COLUMN_COUNT            // MUST be last
     };
     explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);
     ChannelInfoModel(const ChannelInfoModel& other);
     explicit ChannelInfoModel(const QStringList& channelNames);
     QString name     (unsigned i) const;
     QColor  color    (unsigned i) const;
     bool    isVisible(unsigned i) const;
     bool    gainEn   (unsigned i) const;
     double  gain     (unsigned i) const;
     bool    offsetEn (unsigned i) const;
     double  offset   (unsigned i) const;
     /// Returns a list of channel names
     QStringList channelNames() const;
     // implemented from QAbstractItemModel
     int           rowCount(const QModelIndex &parent = QModelIndex()) const;
     int           columnCount(const QModelIndex &parent = QModelIndex()) const;
     QVariant      data(const QModelIndex &index, int role = Qt::DisplayRole) const;
     bool          setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
     Qt::ItemFlags flags(const QModelIndex &index) const;
     QVariant      headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
     void setNumOfChannels(unsigned number);
     /// Stores all channel info into a `QSettings`
     void saveSettings(QSettings* settings) const;
     /// Loads all channel info from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     /// reset all channel info (names, color etc.)
     void resetInfos();
     /// reset all channel names
     void resetNames();
     /// reset all channel colors
     void resetColors();
     /// reset visibility
     void resetVisibility(bool visible);
 private:
     struct ChannelInfo
+    {
         explicit ChannelInfo(unsigned index);
         QString name;
         bool visibility;
         QColor color;
         double gain, offset;
         bool gainEn, offsetEn;
     };
     unsigned _numOfChannels;     ///< @note this is not necessarily the length of `infos`
     /**
      * Channel info is added here but never removed so that we can
      * remember user entered info (names, colors etc.).
      */
     QList<ChannelInfo> infos;
 };
 #endif // CHANNELINFOMODEL_H

src/stream.cpp

➞

Show inline comments

 /*
   Copyright © 2018 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot 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.
   serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "stream.h"
 #include "ringbuffer.h"
 #include "indexbuffer.h"
 Stream::Stream(unsigned nc, bool x, unsigned ns) :
     _infoModel(nc)
+{
     _numSamples = ns;
     _paused = false;
     // create xdata buffer
     _hasx = x;
     if (x)
+    {
         xData = new RingBuffer(ns);
+    }
     else
+    {
         xData = new IndexBuffer(ns);
+    }
     // create channels
     for (unsigned i = 0; i < nc; i++)
+    {
         auto c = new StreamChannel(i, xData, new RingBuffer(ns), &_infoModel);
         channels.append(c);
+    }
+}
 Stream::~Stream()
+{
     for (auto ch : channels)
+    {
         delete ch;
+    }
     delete xData;
+}
 bool Stream::hasX() const
+{
     return _hasx;
+}
 unsigned Stream::numChannels() const
+{
     return channels.length();
+}
 unsigned Stream::numSamples() const
+{
     return _numSamples;
+}
 const StreamChannel* Stream::channel(unsigned index) const
+{
     Q_ASSERT(index < numChannels());
     return channels[index];
+}
 StreamChannel* Stream::channel(unsigned index)
+{
     return const_cast<StreamChannel*>(static_cast<const Stream&>(*this).channel(index));
+}
 const ChannelInfoModel* Stream::infoModel() const
+{
     return &_infoModel;
+}
 ChannelInfoModel* Stream::infoModel()
+{
     return const_cast<ChannelInfoModel*>(static_cast<const Stream&>(*this).infoModel());
+}
 void Stream::setNumChannels(unsigned nc, bool x)
+{
     unsigned oldNum = numChannels();
     if (oldNum == nc && x == _hasx) return;
     // adjust the number of channels
     if (nc > oldNum)
+    {
         for (unsigned i = oldNum; i < nc; i++)
+        {
             auto c = new StreamChannel(i, xData, new RingBuffer(_numSamples), &_infoModel);
             channels.append(c);
+        }
+    }
     else if (nc < oldNum)
+    {
         for (unsigned i = oldNum-1; i > nc-1; i--)
+        {
             delete channels.takeLast();
+        }
+    }
     // change the xdata
     if (x != _hasx)
+    {
         if (x)
+        {
             xData = new RingBuffer(_numSamples);
+        }
         else
+        {
             xData = new IndexBuffer(_numSamples);
+        }
         for (auto c : channels)
+        {
             c->setX(xData);
+        }
         _hasx = x;
+    }
     if (nc != oldNum)
+    {
         _infoModel.setNumOfChannels(nc);
         // TODO: how about X change?
         emit numChannelsChanged(nc);
+    }
     Sink::setNumChannels(nc, x);
+}
 void Stream::feedIn(const SamplePack& data)
+{
     Q_ASSERT(data.numChannels() == numChannels() &&
              data.hasX() == hasX());
     if (_paused) return;
     unsigned ns = data.numSamples();
     if (_hasx)
+    {
         static_cast<RingBuffer*>(xData)->addSamples(data.xData(), ns);
+    }
-    for (unsigned i = 0; i < numChannels(); i++)
+    for (unsigned ci = 0; ci < numChannels(); ci++)
+    {
         static_cast<RingBuffer*>(channels[i]->yData())->addSamples(data.data(i), ns);
         // TODO: check for gainEn and offsetEn
         // apply gain and offset
         auto rdata = data.data(ci);
         auto mdata = new double[sizeof(double) * ns];
         // TODO: add gain&offset access methods to `StreamChannel`
         double gain = channels[ci]->info()->gain(ci);
         double offset = channels[ci]->info()->offset(ci);
         for (int i = 0; i < ns; i++)
+        {
             mdata[i] = rdata[i] * gain + offset;
+    }
         static_cast<RingBuffer*>(channels[ci]->yData())->addSamples(mdata, ns);
         delete[] mdata;
+    }
     // TODO: emit modified (gain&offset) data
     Sink::feedIn(data);
     emit dataAdded();
+}
 void Stream::pause(bool paused)
+{
     _paused = paused;
+}
 void Stream::clear()
+{
     for (auto c : channels)
+    {
         static_cast<RingBuffer*>(c->yData())->clear();
+    }
+}
 void Stream::setNumSamples(unsigned value)
+{
     if (value == _numSamples) return;
     _numSamples = value;
     xData->resize(value);
     for (auto c : channels)
+    {
         static_cast<RingBuffer*>(c->yData())->resize(value);
+    }
+}
 void Stream::saveSettings(QSettings* settings) const
+{
     _infoModel.saveSettings(settings);
+}
 void Stream::loadSettings(QSettings* settings)
+{
     _infoModel.loadSettings(settings);
+}

0 comments (0 inline, 0 general)