TransferPoints.h

#pragma once
#include "Clustering.h"

#include <QObject>
#include <QRectF>
#include <QVector>
#include <QSizeF>
#include <QPen>
#include <QBrush>
#include <QPointF>
#include <QWidget>
#include <QColor>

#include "GLM/gtx.hpp"
#include "GLM/gtc.hpp"
#include "GLM/gtx/type_ptr.hpp"

#include "TPoint.h"

class TFObjects
{
public:
        int type;
        glm::vec2 size;
        glm::vec2 pos;
        glm::vec2 scale;
        int rotate;
        QColor color;
        QPainterPath path;

        glm::vec2 m;
        glm::mat2 c;
};

class TransferPoints : public QObject
{
        Q_OBJECT

public:
        enum PointShape {
        CircleShape,
        RectangleShape
    };

        enum LockType {
                LockToLeft   = 0x01,
                LockToRight  = 0x02,
                LockToTop    = 0x04,
                LockToBottom = 0x08
        };

        enum EventObjectType 
        {
                Selection               = 0,
                DrawPoint               = 1,
                DrawEllipse             = 2,
                DrawRectangle   = 3
        };

        enum SortType {
                NoSort,
                XSort,
                YSort
        };

        enum ConnectionType {
                NoConnection,
                LineConnection,
                CurveConnection
        };

        TransferPoints(QWidget *widget, PointShape shape);

        bool eventFilter(QObject *object, QEvent *event);

        void paintPoints();

        inline QRectF boundingRect() const;
        void setBoundingRect(const QRectF &boundingRect) { m_bounds = boundingRect; }

        const QVector<TPoint>& points() const;
        void setPoints(const QVector<TPoint> &points);

        QSizeF pointSize() const { return m_pointSize; }
        void setPointSize(const QSizeF &size) { m_pointSize = size; }
        
        SortType sortType() const { return m_sortType; }
        void setSortType(SortType sortType) { m_sortType = sortType; }
        
        ConnectionType connectionType() const { return m_connectionType; }
        void setConnectionType(ConnectionType connectionType) { m_connectionType = connectionType; }

        void setConnectionPen(const QPen &pen) { m_connectionPen = pen; }
        void setShapePen(const QPen &pen) { m_pointPen = pen; }
        void setShapeBrush(const QBrush &brush) { m_pointBrush = brush; }

        void setPointLock(int pos, LockType lock) { m_locks[pos] = lock; }

        void setEditable(bool editable) { m_editable = editable; }
        bool editable() const { return m_editable; }


public slots:
        void setEnabled(bool enabled);

        void setDisabled(bool disabled) { setEnabled(!disabled); }

        void changePointColor(QColor c) {p_color = c;}

        void updateHistogram(double* histogram, int size);

        void updateValues(glm::vec2* values, int size);

        void updateMode(int mode);

        void DoClustering(int K);


        void updateActionObjectType(int type);
signals:

        void pointsChanged(int);
public:

        void firePointChange();

        std::vector<TFObjects> tf_objects;

private:
        inline QRectF pointBoundingRect(int i) const;

        inline QRectF insertBoundingRect(int i) const;

        void movePoint(int i, const TPoint &newPos, bool emitChange = true);
        
        QWidget* m_widget;

        QVector<TPoint>* m_points;
        
        QRectF m_bounds;

        PointShape m_shape;
        SortType m_sortType;
        ConnectionType m_connectionType;
        QVector<uint> m_locks;
        QSizeF m_pointSize;
        int m_currentIndex;
        
        bool m_editable;
        bool m_enabled;
        
        QPen m_pointPen;
        QBrush m_pointBrush;
        QPen m_connectionPen;
        QColor p_color;

        double* hist;
        int histSize;
        //void drawHistogram(QPainter p);

        glm::vec2* valuesX;
        // Stores Size
        int sizeX;

        //Stores Mode
        int m_mode;

        //Defines the current Operation for Actions
        int m_action_type;

        QPainterPath drawing_path;
        glm::vec2 start_rectangle;
        glm::vec2 act_rectangle;
        bool newAction;
};


inline QRectF TransferPoints::pointBoundingRect(int i) const
{
        int mode = m_mode;
        TPoint p = m_points[mode].at(i);
        double w = m_pointSize.width();
        double h = m_pointSize.height();
        double x = p.x() - w / 2;
        double y = p.y() - h / 2;
        return QRectF(x, y, w, h);
}

inline QRectF TransferPoints::insertBoundingRect(int i) const
{
        int mode = m_mode;
        TPoint p = m_points[mode].at(i);
        double w = m_pointSize.width() * 2.0;
        double h = m_pointSize.height() * 2.0;
        double x = p.x() - w / 2;
        double y = p.y() - h / 2;
        return QRectF(x, y, w, h);
}

inline QRectF TransferPoints::boundingRect() const
{
         if (m_bounds.isEmpty())
                 return m_widget->rect();
         else
                 return m_bounds;
};