#include <memory>
#include <QtCore/QObject>
+#include <QDebug>
+
struct GraphDrawData {
GraphDrawData() :
ddata(nullptr), ddataLen(0) {}
const double auc, time;
};
+struct RulerDrawData {
+ RulerDrawData() : firstTickAbs(0), firstTickRel(0), step(0), relStep(0) {}
+ RulerDrawData(const double fta, const double ftr, const double s, const double rs) : firstTickAbs(fta), firstTickRel(ftr), step(s), relStep(rs)
+ {}
+
+ const double firstTickAbs;
+ const double firstTickRel;
+ const double step;
+ const double relStep;
+};
+
class SignalController : public QObject
{
Q_OBJECT
public:
+ enum class Axis { TIME, VALUE };
+
explicit SignalController(std::shared_ptr<Signal> signal, QObject* parent = nullptr);
~SignalController();
- /*double currentYMax() const { return m_yMax; }
- double currentYMin() const { return m_yMin; }
- double currentStartX() const;
- double currentStartY() const;
- double currentStopX() const;
- double currentStopY() const;
- void draw();*/
- SignalDataTableModel* dataTableModel() { return m_dtblModel; }
+ SignalDataTableModel* dataTableModel() { return m_dtblModel; }
PeakDrawData deletePeak(const double x);
- //double* generateDrawData(size_t from, size_t to);
Signal::TimeValuePair getXYValues(const double x);
std::shared_ptr<GraphDrawData> getGraphDrawData(const double fromX, const double toX);
std::vector<PeakDrawData> getPeaksDrawData(const double fromX, const double fromY, const double toX, const double toY);
+ RulerDrawData getRulerDrawData(const double from, const double to, SignalController::Axis axis);
double fromXAbs() const { return m_signal->timeAt(0); }
double toXAbs() const { return m_signal->timeAt(m_signal->count()-1); }
double fromYAbs() const { return m_signal->valueAt(0); }
static const double RELATIVE_MIN;
private:
- //GraphViewContextMenu m_ctxMenu;
- //int m_ctxMenuX;
- //int m_ctxMenuY;
SignalDataTableModel* m_dtblModel;
- //uint m_fromIdx;
- //uint m_toIdx;
IntegrationTableModel* m_integTblModel;
std::shared_ptr<Integrator> m_integrator;
std::shared_ptr<Signal> m_signal;
- //int m_viewHeight;
- //int m_viewWidth;
- //double m_yMax;
- //double m_yMin;
double idxToRel(const size_t idx);
double valueToRel(const double value);
size_t relToIdx(const double rel);
double relToValue(const double rel);
- //void drawAllPeaks();
- //void drawFullGraph();
- //void drawGraph();
void drawIntegratedPeak(const std::shared_ptr<IntegratedPeak> peak);
PeakDrawData genPeakDrawData(const std::shared_ptr<IntegratedPeak> peak);
- //bool updateConstraints(const int fromX, const int fromY, const int toX, const int to);
- //double yValToCoord(double y);
static const QString ME_SENDER_STR;
public slots:
- /*void onCtxMenuUnzoom();
- void onCtxMenuDeletePeak();
- void onViewCrosshairErased();
- void onViewCrosshairMoved(const int x, const int y);
- void onViewIntegrated(const int fromX, const int fromY, const int toX, const int toY);
- void onViewRedrawNeeded();
- void onViewResized(const int w, const int h);
- void onViewShowContextMenu(const int x, const int y, const QPoint& globalPos);
- bool onViewZoomed(const int fromX, const int fromY, const int toX, const int toY);
- bool onViewZoomedByValues(const double fromX, const double fromY, const double toX, const double toY);*/
signals:
- //void viewCtxMenuClosed();
- //void viewDrawGraph(double* data, size_t len, double min, double max);
- //void viewDrawIntegration(int startX, double startY, int stopX, double stopY, int peakStartX, double peakStartY, const QString& time, const QString& area);
- //void viewUpdateCurrentValues(double x, double y);
- //void viewRemoveCurrentValues();
void fillDataList();
};
#include <QDebug>
const QString SignalDrawer::ME_SENDER_STR("SignalDrawer");
+const int SignalDrawer::SCALE_MARGIN_TIME(16);
+const int SignalDrawer::SCALE_MARGIN_VALUE(48);
SignalDrawer::SignalDrawer(std::shared_ptr<SignalController> controller) :
m_controller(controller),
bool SignalDrawer::draw(const double fromX, const double fromY, const double toX, const double toY)
{
+ QPixmap* fresh;
bool ret;
setNewRelativeConstraints(fromX, fromY, toX, toY);
- ret = drawGraph(fromX, fromY, toX, toY);
+ fresh = createFreshPixmap();
+ if (fresh == nullptr)
+ return false;
+ ret = drawGraph(fresh);
if (!ret) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " cannot draw graph");
restoreRelativeConstraints();
+ delete fresh;
return ret;
}
- ret = drawPeaks(fromX, fromY, toX, toY);
+ ret = renderScale(SignalController::Axis::VALUE, fresh);
+ ret = renderScale(SignalController::Axis::TIME, fresh);
+ ret = drawPeaks(fresh);
if (!ret) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " cannot draw integrated peaks");
restoreRelativeConstraints();
+ delete fresh;
return ret;
}
+ renderFresh(fresh);
- return ret;
+ return true;
}
bool SignalDrawer::setDimensions(const int width, const int height)
{
- if (width < 0 || height < 0) {
+ if (width < SCALE_MARGIN_VALUE || height < SCALE_MARGIN_TIME) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " invalid dimensions (" + QString::number(width) + ", " + QString::number(height) + ")");
return false;
}
- m_width = width;
m_height = height;
+ m_width = width;
+ m_gWidth = width - SCALE_MARGIN_VALUE;
+ m_gHeight = height - SCALE_MARGIN_TIME;
+
+ qDebug() << __QFUNC__ << width << height << m_width << m_height;
return draw();
}
/** Protected methods **/
-bool SignalDrawer::drawGraph(const double fromX, const double fromY, const double toX, const double toY)
+void SignalDrawer::copyPixmapRegion(const QRect& rect, QPixmap* const source, QPixmap* const target)
{
- std::shared_ptr<GraphDrawData> gdData = m_controller->getGraphDrawData(fromX, toX);
+ QPainter p(target);
+
+ p.drawPixmap(rect, *source, rect);
+}
+
+bool SignalDrawer::drawGraph(QPixmap* const target)
+{
+ std::shared_ptr<GraphDrawData> gdData = m_controller->getGraphDrawData(m_relXMin, m_relXMax);
if (gdData->ddataLen == 0)
return false;
m_gdData = gdData;
- return renderGraph(fromY, toY);
+ return renderGraph(target);
}
-bool SignalDrawer::drawPeaks(const double fromX, const double fromY, const double toX, const double toY)
+bool SignalDrawer::drawPeaks(QPixmap* const target)
{
- std::vector<PeakDrawData> pdData = m_controller->getPeaksDrawData(fromX, fromY, toX, toY);
+ std::vector<PeakDrawData> pdData = m_controller->getPeaksDrawData(m_relXMin, m_relYMin, m_relXMax, m_relYMax);
if (pdData.size() < 1)
return true;
for (const PeakDrawData& pd : pdData) {
- QRegion reg = renderPeak(pd);
+ QRegion reg = renderPeak(pd, target);
if (reg.isEmpty()) return false;
}
return true;
}
-QRegion SignalDrawer::erasePeak(const PeakDrawData& pd)
+bool SignalDrawer::renderScale(const SignalController::Axis axis, QPixmap* const target)
+{
+ QPainter p;
+ int absVal;
+ double relMin, relMax;
+ std::function<void (const double, const TickType)> tickDrawFunc;
+ std::function<void (const double, const double)> textDrawFunc;
+
+ if (target == nullptr) {
+ Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " null pointer to pixmap");
+ return false;
+ }
+
+ p.begin(target);
+ switch (axis) {
+ case SignalController::Axis::TIME:
+ relMin = m_relXMin; relMax = m_relXMax;
+ tickDrawFunc = std::bind(&SignalDrawer::renderTimeScaleTick, this, &p, std::placeholders::_1, std::placeholders::_2);
+ textDrawFunc = std::bind(&SignalDrawer::renderTimeScaleText, this, &p, std::placeholders::_1, std::placeholders::_2);
+ p.drawLine(SCALE_MARGIN_VALUE, m_gHeight + 1, m_gWidth + SCALE_MARGIN_VALUE, m_gHeight + 1);
+ break;
+ case SignalController::Axis::VALUE:
+ relMin = m_relYMin; relMax = m_relYMax;
+ tickDrawFunc = std::bind(&SignalDrawer::renderValueScaleTick, this, &p, std::placeholders::_1, std::placeholders::_2);
+ textDrawFunc = std::bind(&SignalDrawer::renderValueScaleText, this, &p, std::placeholders::_1, std::placeholders::_2);
+ p.drawLine(SCALE_MARGIN_VALUE - 1, 0, SCALE_MARGIN_VALUE - 1, m_gHeight);
+ break;
+ }
+
+ RulerDrawData rd = m_controller->getRulerDrawData(relMin, relMax, axis);
+
+ if (axis == SignalController::Axis::VALUE)
+ qDebug() << __QFUNC__ << "step" << rd.step << "relStep" << rd.relStep;
+
+ /* Draw subticks before the first tick */
+ {
+ int ctr = 10;
+ for (double subRel = rd.firstTickRel; subRel >= relMin; subRel -= rd.relStep / 10)
+ tickDrawFunc(subRel, (--ctr == 5) ? TickType::TICK : TickType::SUBTICK);
+ }
+ /* Draw ticks */
+ absVal = rd.firstTickAbs;
+ for (double rel = rd.firstTickRel; rel <= relMax; rel += rd.relStep) {
+ tickDrawFunc(rel, TickType::TICK);
+ textDrawFunc(rel, absVal);
+ absVal += rd.step;
+
+ /* Draw subticks ticks */
+ double subRel = rel;
+ for (uint i = 1; i < 10; i++) {
+ subRel += rd.relStep / 10;
+ tickDrawFunc(subRel, (i == 5) ? TickType::TICK : TickType::SUBTICK);
+ }
+
+ }
+ p.end();
+
+ return true;
+}
+
+void SignalDrawer::renderTimeScaleText(QPainter*const p, const double rel, const double value)
+{
+ const int xPix = relToXPix(rel);
+
+ p->drawText(xPix + 2, m_gHeight + 15, m_locale.toString(value, 'f', 3));
+}
+
+void SignalDrawer::renderValueScaleText(QPainter*const p, const double rel, const double value)
+{
+ const int yPix = relToYPix(rel);
+
+ p->drawText(1, yPix + 5, m_locale.toString(value, 'f', 2));
+}
+
+void SignalDrawer::renderTimeScaleTick(QPainter*const p, const double rel, const TickType tt)
+{
+ const int xPix = relToXPix(rel);
+
+ switch (tt) {
+ case TickType::TICK:
+ p->drawLine(xPix, m_gHeight + 2, xPix, m_gHeight + 6);
+ break;
+ case TickType::SUBTICK:
+ p->drawLine(xPix, m_gHeight + 2, xPix , m_gHeight + 4);
+ break;
+ }
+}
+
+void SignalDrawer::renderValueScaleTick(QPainter*const p, const double rel, const TickType tt)
+{
+ const int yPix = relToYPix(rel);
+
+ qDebug() << __QFUNC__ << "yPix" << yPix << "rel" << rel;
+
+ switch (tt) {
+ case TickType::TICK:
+ p->drawLine(SCALE_MARGIN_VALUE - 6, yPix, SCALE_MARGIN_VALUE - 1, yPix);
+ break;
+ case TickType::SUBTICK:
+ p->drawLine(SCALE_MARGIN_VALUE - 4, yPix, SCALE_MARGIN_VALUE - 1, yPix);
+ break;
+ }
+}
+
+QRect SignalDrawer::erasePeak(const PeakDrawData& pd)
{
QPainter p;
QFont font("arial", 10);
if (m_background == nullptr) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " null pointer to pixmap");
- return QRegion();
+ return QRect();
}
/* No peak */
if (pd.auc == 0)
- return QRegion();
+ return QRect();
- fromXPix = relToXPix(pd.fromX); fromYPix = relToYPix(pd.fromY);
- toXPix = relToXPix(pd.toX); toYPix = relToYPix(pd.toY);
- peakX = relToXPix(pd.peakX); peakY = relToYPix(pd.peakY);
+ fromXPix = relToXPix(pd.fromX) + SCALE_MARGIN_VALUE; fromYPix = relToYPix(pd.fromY);
+ toXPix = relToXPix(pd.toX) + SCALE_MARGIN_VALUE; toYPix = relToYPix(pd.toY);
+ peakX = relToXPix(pd.peakX) + SCALE_MARGIN_VALUE; peakY = relToYPix(pd.peakY);
aucText = m_locale.toString(pd.auc, 'f', 4);
timeText = m_locale.toString(pd.time, 'f', 4);
tTextWidth = fm.width(timeText);
else
endXPix = toXPix;
- return QRegion(beginXPix, 0, endXPix - beginXPix, m_height);
+ return QRect(beginXPix, 0, endXPix - beginXPix, m_height);
}
-bool SignalDrawer::renderGraph(const double fromY, const double toY)
+bool SignalDrawer::renderGraph(QPixmap* const target)
{
- QPixmap* pixmap;
QPainter p;
double xStep, yStep;
- int fromXPix = 0, fromYPix;
+ int fromXPix = SCALE_MARGIN_VALUE, fromYPix;
- if (m_width < 1 || m_height < 1) {
+ if (m_width < SCALE_MARGIN_VALUE || m_height < SCALE_MARGIN_VALUE) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " invalid dimensions (" + QString::number(m_width) + ", " + QString::number(m_height) + ")");
return false;
}
return false;
}
- pixmap = new QPixmap(m_width, m_height);
- p.begin(pixmap);
+ p.begin(target);
p.fillRect(0, 0, m_width, m_height, Qt::white);
p.setPen(QColor(Qt::blue));
- xStep = static_cast<double>(m_width) / m_gdData->ddataLen;
- yStep = static_cast<double>(m_height) / (toY - fromY);
+ xStep = static_cast<double>(m_gWidth) / m_gdData->ddataLen;
+ yStep = static_cast<double>(m_gHeight) / (m_relYMax - m_relYMin);
Logger::log(Logger::Level::DEBUG, ME_SENDER_STR, __QFUNC__ + " yStep: " + QString::number(yStep)
- + " fY " + QString::number(fromY) + " tY " + QString::number(toY));
- fromYPix = m_height - yStep * (m_gdData->ddata[0] - fromY);
+ + " fY " + QString::number(m_relYMin) + " tY " + QString::number(m_relYMax));
+ fromYPix = m_gHeight - yStep * (m_gdData->ddata[0] - m_relYMin);
for (size_t i = 1; i < m_gdData->ddataLen; i++) {
- int toXPix = xStep * i;
- int toYPix = m_height - yStep * (m_gdData->ddata[i] - fromY);
+ int toXPix = xStep * i + SCALE_MARGIN_VALUE;
+ int toYPix = m_gHeight - yStep * (m_gdData->ddata[i] - m_relYMin);
p.drawLine(fromXPix, fromYPix, toXPix, toYPix);
fromXPix = toXPix;
fromYPix = toYPix;
p.end();
+
+ return true;
+}
+
+void SignalDrawer::renderFresh(QPixmap* const fresh)
+{
if (m_pixmap)
delete m_pixmap;
- m_pixmap = pixmap;
+ m_pixmap = fresh;
if (m_background)
delete m_background;
m_background = new QPixmap(*m_pixmap);
-
- return true;
}
-QRegion SignalDrawer::renderPeak(const PeakDrawData& pd)
+
+QRect SignalDrawer::renderPeak(const PeakDrawData& pd, QPixmap* const target)
{
QPainter p;
QFont font("arial", 10);
int peakX, peakY;
int beginXPix, endXPix;
- if (m_background == nullptr) {
+ if (target == nullptr) {
Logger::log(Logger::Level::WARNING, ME_SENDER_STR, __QFUNC__ + " null pointer to pixmap");
- return QRegion();
+ return QRect();
}
/* No peak */
if (pd.auc == 0)
- return QRegion();
+ return QRect();
fromXPix = relToXPix(pd.fromX); fromYPix = relToYPix(pd.fromY);
toXPix = relToXPix(pd.toX); toYPix = relToYPix(pd.toY);
peakX = relToXPix(pd.peakX); peakY = relToYPix(pd.peakY);
aucText = m_locale.toString(pd.auc, 'f', 4);
- timeText = m_locale.toString(pd.time, 'f', 4);
+ timeText = QString("A:") + m_locale.toString(pd.time, 'f', 4);
- p.begin(m_background);
+ p.begin(target);
p.setPen(Qt::red);
p.drawLine(fromXPix, fromYPix, toXPix, toYPix);
else
endXPix = toXPix;
- /* Copy peak to foreground pixmap */
- p.begin(m_pixmap);
- p.drawPixmap(beginXPix, 0, *m_background, beginXPix, 0, endXPix - beginXPix, m_height);
- p.end();
-
- return QRegion(beginXPix, 0, endXPix - beginXPix, m_height);
+ return QRect(beginXPix, 0, endXPix - beginXPix, m_height);
}
/** Private functions **/
int SignalDrawer::relToXPix(const double rel)
{
- const int ret = m_width / (m_relXMax - m_relXMin) * (rel - m_relXMin);
+ const int ret = m_gWidth / (m_relXMax - m_relXMin) * (rel - m_relXMin) + SCALE_MARGIN_VALUE;
//qDebug() << __QFUNC__ << ret;
return ret;
}
int SignalDrawer::relToYPix(const double rel)
{
- const int ret = m_height - (m_height / (m_relYMax - m_relYMin) * (rel - m_relYMin));
+ const int ret = m_gHeight - (m_gHeight / (m_relYMax - m_relYMin) * (rel - m_relYMin));
//qDebug() << __QFUNC__ << ret;
return ret;
}
double SignalDrawer::xPixToRel(const int pix)
{
- const double ret = (pix * (m_relXMax - m_relXMin) / m_width) + m_relXMin;
+ double ret;
+ if (pix < SCALE_MARGIN_VALUE)
+ return 0.0;
+ ret = ((pix - SCALE_MARGIN_VALUE) * (m_relXMax - m_relXMin) / m_gWidth) + m_relXMin;
//qDebug() << __QFUNC__ << ret;
return ret;
}
double SignalDrawer::yPixToRel(const int pix)
{
const double range = m_relYMax - m_relYMin;
- const int invPix = m_height - pix;
- const double ret = (range / m_height * invPix) + m_relYMin;
- //qDebug() << __QFUNC__ << ret;
- return ret;
+ const int invPix = m_gHeight - pix;
+ if (invPix < 0)
+ return 0;
+ return (range / m_gHeight * invPix) + m_relYMin;
}
/** Private methods **/
m_oldRelYMin = m_relYMin;
m_oldRelYMax = m_relYMax;
- m_relXMin = fromX;
- m_relXMax = toX;
- m_relYMin = fromY;
- m_relYMax = toY;
+ if (fromX < toX) {
+ m_relXMin = fromX;
+ m_relXMax = toX;
+ } else {
+ m_relXMin = toX;
+ m_relXMax = fromX;
+ }
+
+ if (fromY < toY) {
+ m_relYMin = fromY;
+ m_relYMax = toY;
+ } else {
+ m_relYMin = toY;
+ m_relYMax = fromY;
+ }
}
SignalDrawer::~SignalDrawer()
git://gitweb.devoid-pointer.net / anyanka.git / commitdiff