spline.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef SPLINE_H
#define SPLINE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp_global.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QWidget>
#include <QVector3D>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class QMouseEvent;
 
//=============================================================================================================
// DEFINE NAMESPACE DISPLIB
//=============================================================================================================
 
namespace DISPLIB
{
 
//=============================================================================================================
// DISPLIB FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class DISPSHARED_EXPORT Spline : public QWidget
{
    Q_OBJECT
 
public:
    typedef QSharedPointer<Spline> SPtr;            
    typedef QSharedPointer<const Spline> ConstSPtr; 
 
    //=========================================================================================================
    Spline(QWidget* parent = nullptr, const QString& title = "Spline Histogram");
 
    //=========================================================================================================
    template<typename T>
    void setData(const Eigen::Matrix<T, Eigen::Dynamic, 1>& matClassLimitData,
                 const Eigen::Matrix<int, Eigen::Dynamic, 1>& matClassFrequencyData);
    template<typename T>
    void setData(const Eigen::Matrix<T, 1, Eigen::Dynamic>& matClassLimitData,
                 const Eigen::Matrix<int, 1, Eigen::Dynamic>& matClassFrequencyData);
 
    //=========================================================================================================
    template<typename T>
    void updatePlot(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matClassLimitData,
                    const Eigen::VectorXi& matClassFrequencyData);
 
    //=========================================================================================================
    void mousePressEvent(QMouseEvent* event) override;
 
    //=========================================================================================================
    template<typename T>
    void splitCoefficientAndExponent(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matClassLimitData,
                                     int iClassAmount,
                                     Eigen::VectorXd& vecCoefficientResults,
                                     Eigen::VectorXi& vecExponentValues);
 
    //=========================================================================================================
    void setThreshold(const QVector3D& vecThresholdValues);
 
    //=========================================================================================================
    const QVector3D& getThreshold();
 
    //=========================================================================================================
    QVector3D correctionDisplayTrueValue(QVector3D vecOriginalValues,
                                         QString upOrDown);
 
    //=========================================================================================================
    void setColorMap(const QString& colorMap);
 
    Eigen::VectorXi m_vecResultExponentValues; 
    double m_dMinAxisX;                        
    double m_dMaxAxisX;                        
 
protected:
    //=========================================================================================================
    void paintEvent(QPaintEvent* event) override;
 
    //=========================================================================================================
    double dataToPixelX(double dataX) const;
 
    //=========================================================================================================
    double dataToPixelY(double dataY) const;
 
    //=========================================================================================================
    double pixelToDataX(double pixelX) const;
 
    //=========================================================================================================
    int leftMargin() const
    {
        return 60;
    }
 
    //=========================================================================================================
    int rightMargin() const
    {
        return 20;
    }
 
    //=========================================================================================================
    int topMargin() const
    {
        return 30;
    }
 
    //=========================================================================================================
    int bottomMargin() const
    {
        return 40;
    }
 
    QList<QPointF> m_seriesData; 
    double m_dLeftThreshold;     
    double m_dMiddleThreshold;   
    double m_dRightThreshold;    
    bool m_bHasData;             
    bool m_bHasThresholds;       
    int m_iMaximumFrequency;     
    QString m_colorMap;          
    QVector3D m_vecReturnVector; 
 
signals:
    //=========================================================================================================
    void borderChanged(double leftThreshold, double middleThreshold, double rightThreshold);
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
template<typename T>
void Spline::setData(const Eigen::Matrix<T, Eigen::Dynamic, 1>& matClassLimitData,
                     const Eigen::Matrix<int, Eigen::Dynamic, 1>& matClassFrequencyData)
{
    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> matrixName(matClassLimitData.rows(), 1);
    matrixName.col(0) = matClassLimitData;
    this->updatePlot(matrixName, matClassFrequencyData);
}
 
//=========================================================================================================
 
template<typename T>
void Spline::setData(const Eigen::Matrix<T, 1, Eigen::Dynamic>& matClassLimitData,
                     const Eigen::Matrix<int, 1, Eigen::Dynamic>& matClassFrequencyData)
{
    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> matrixName(1, matClassLimitData.cols());
    matrixName.row(0) = matClassLimitData;
    this->updatePlot(matrixName, matClassFrequencyData);
}
 
//=========================================================================================================
 
template<typename T>
void Spline::updatePlot(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matClassLimitData,
                        const Eigen::VectorXi& matClassFrequencyData)
{
    Eigen::VectorXd resultDisplayValues;
    int iClassAmount = std::min(static_cast<int>(matClassFrequencyData.rows()),
                                static_cast<int>(matClassLimitData.rows()) - 1);
    if (iClassAmount < 1)
        return;
    this->splitCoefficientAndExponent(matClassLimitData, iClassAmount, resultDisplayValues, m_vecResultExponentValues);
 
    m_dMinAxisX = resultDisplayValues(0);
    m_dMaxAxisX = resultDisplayValues(iClassAmount);
 
    m_seriesData.clear();
    m_iMaximumFrequency = 0;
 
    for (int ir = 0; ir < iClassAmount; ++ir) {
        double classMark = (resultDisplayValues(ir) + resultDisplayValues(ir + 1)) / 2.0;
        m_seriesData.append(QPointF(classMark, matClassFrequencyData(ir)));
        if (matClassFrequencyData(ir) > m_iMaximumFrequency) {
            m_iMaximumFrequency = matClassFrequencyData(ir);
        }
    }
 
    m_bHasData = true;
    m_dLeftThreshold = m_dMinAxisX;
    m_dMiddleThreshold = m_dMaxAxisX;
    m_dRightThreshold = m_dMaxAxisX;
    m_bHasThresholds = false;
 
    QWidget::update();
}
 
//=============================================================================================================
 
template<typename T>
void Spline::splitCoefficientAndExponent(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matClassLimitData,
                                         int iClassAmount,
                                         Eigen::VectorXd& vecCoefficientResults,
                                         Eigen::VectorXi& vecExponentValues)
{
    vecCoefficientResults.resize(iClassAmount + 1);
    vecExponentValues.resize(iClassAmount + 1);
    double originalValue(0.0),
        limitDisplayValue(0.0),
        doubleExponentValue(0.0);
    int limitExponentValue(0);
    for (int ir = 0; ir <= iClassAmount; ++ir) {
        originalValue = matClassLimitData(ir);
        if (originalValue == 0.0) {
            doubleExponentValue = 0.0;
        } else {
            doubleExponentValue = log10(std::fabs(originalValue));
        }
 
        limitExponentValue = round(doubleExponentValue);
        limitDisplayValue = originalValue * (pow(10, -(limitExponentValue)));
        vecCoefficientResults(ir) = limitDisplayValue;
        vecExponentValues(ir) = limitExponentValue;
    }
 
    int lowestExponentValue{0},
        highestExponentValue{0};
 
    for (int ir = 0; ir <= iClassAmount; ++ir) {
        if (vecExponentValues(ir) < lowestExponentValue) {
            lowestExponentValue = vecExponentValues(ir);
        }
        if (vecExponentValues(ir) > highestExponentValue) {
            highestExponentValue = vecExponentValues(ir);
        }
    }
 
    if (highestExponentValue > 0) {
        for (int ir = 0; ir <= iClassAmount; ++ir) {
            while (vecExponentValues(ir) < highestExponentValue) {
                vecCoefficientResults(ir) = vecCoefficientResults(ir) / 10;
                vecExponentValues(ir)++;
            }
        }
    }
 
    if (lowestExponentValue < 0) {
        for (int ir = 0; ir <= iClassAmount; ++ir) {
            while (vecExponentValues(ir) > lowestExponentValue) {
                vecCoefficientResults(ir) = vecCoefficientResults(ir) * 10;
                vecExponentValues(ir)--;
            }
        }
    }
}
} // NAMESPACE
 
#endif // SPLINE_H