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 <QtCharts/QChart>
#include <QtCharts/QSplineSeries>
#include <QVector3D>

//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================

#include <Eigen/Core>

//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================

class QMouseEvent;

namespace QtCharts
{
    class QLineSeries;
}

//=============================================================================================================
// 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 = 0, 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);

    //=========================================================================================================
    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 functionName);

    //=========================================================================================================
    void setColorMap (const QString &colorMap);

    Eigen::VectorXi m_vecResultExponentValues; 
    double          m_dMinAxisX;               
    double          m_dMaxAxisX;               
protected:
    //=========================================================================================================
    void updateThreshold (QtCharts::QLineSeries *lineSeries);

    QtCharts::QChart*        m_pChart;            
    QtCharts::QSplineSeries* m_pSeries;           
    QtCharts::QLineSeries*   m_pLeftThreshold;    
    QtCharts::QLineSeries*   m_pMiddleThreshold;  
    QtCharts::QLineSeries*   m_pRightThreshold;   
    int                      m_iMaximumFrequency; 
    QList<QVector3D>         m_pReturnList;       
    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 = matClassFrequencyData.rows();
    this->splitCoefficientAndExponent (matClassLimitData, iClassAmount, resultDisplayValues, m_vecResultExponentValues);

    //  Start of Qtchart histogram display
    QString histogramExponent;
    histogramExponent = "X-axis scale: 10e" + QString::number(m_vecResultExponentValues(0));   //used to tell the user the exponential scale used in the histogram
    m_pSeries->setName(histogramExponent);
    m_pSeries->clear();
    m_pChart->removeSeries(m_pSeries);
    m_pChart->removeSeries(m_pLeftThreshold);              //create new series and then clear the plot and update with new data
    m_pChart->removeSeries(m_pMiddleThreshold);
    m_pChart->removeSeries(m_pRightThreshold);

    m_dMinAxisX = resultDisplayValues(0);
    m_dMaxAxisX = resultDisplayValues(iClassAmount);
    double classMark;                         //class mark is the middle point between lower and upper class limit
    m_iMaximumFrequency = 0;                    //iMaximumFrequency used to create an intuitive histogram

    for (int ir = 0; ir < iClassAmount; ++ir)
    {
        classMark = (resultDisplayValues(ir) + resultDisplayValues(ir+1))/2 ;
        m_pSeries->append(classMark, matClassFrequencyData(ir));
        //std::cout << "Spline data points = " << classMark << ", " << matClassFrequencyData(ir) << std::endl;
        if (matClassFrequencyData(ir) > m_iMaximumFrequency)
        {
            m_iMaximumFrequency = matClassFrequencyData(ir);
        }
    }
    m_pLeftThreshold = new QtCharts::QLineSeries();
    m_pMiddleThreshold = new QtCharts::QLineSeries();
    m_pRightThreshold = new QtCharts::QLineSeries();
    m_pLeftThreshold->setName("left");
    m_pMiddleThreshold->setName("middle");
    m_pRightThreshold->setName("right");

    m_pChart->addSeries(m_pSeries);
    m_pChart->legend()->setVisible(true);
    m_pChart->legend()->setAlignment(Qt::AlignBottom);
    m_pChart->createDefaultAxes();
    m_pChart->axisX()->setRange(m_dMinAxisX, m_dMaxAxisX);
}

//=============================================================================================================

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)                          //mechanism to guard against evaluation of log(0.0) which is infinity
        {
            doubleExponentValue = 0.0;
        }

        else
        {
            doubleExponentValue = log10(std::fabs(originalValue));                    //return the exponent value in double
        }

        limitExponentValue = round(doubleExponentValue);                        //round the exponent value to the nearest signed integer
        limitDisplayValue = originalValue * (pow(10,-(limitExponentValue)));    //display value is derived from multiplying class limit with inverse 10 to the power of negative exponent
        vecCoefficientResults(ir) = limitDisplayValue;                          //append the display value to the return vector
        vecExponentValues(ir) = limitExponentValue;                             //append the exponent value to the return vector
    }

    int lowestExponentValue{0},
    highestExponentValue{0};

    for (int ir = 0; ir <= iClassAmount; ++ir)
    {
        if (vecExponentValues(ir) < lowestExponentValue)
        {
            lowestExponentValue = vecExponentValues(ir);        //find lowest exponent value to normalize display values for negative exponent
        }
        if (vecExponentValues(ir) > highestExponentValue)       //find highest exponent value to normalize display values for positive exponent
        {
            highestExponentValue = vecExponentValues(ir);
        }
    }

    if (highestExponentValue > 0)
    {
        for (int ir = 0; ir <= iClassAmount; ++ir)
        {
            while (vecExponentValues(ir) < highestExponentValue)     //normalize the values by multiplying the display value by 10 and reducing the exponentValue by 1 until exponentValue reach the lowestExponentValue
            {
                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