Datapool.h

#ifndef __DATAPOOL_H__
#define __DATAPOOL_H__


#include <QImage>
#ifdef __COMPILE_QT5__
    #include <QtWidgets/QTextEdit>
#else
    #include<QTextEdit>
#endif
#include "opencvCompatibilityVersion.h"
#include <deque>
#include <map>
#include "src/calibration.h"
#include "src/blob.h"
#include "src/hullmodel.h"
#include "src/object.h"
#include "src/ModelInterface.h"
#include "src/ImageHeader.h"
#include "src/MobileObject.h"
#include "src/MobileObject2D.h"
#include "src/RMMT/RMMMobileObject.h"
#include "src/rlesegment.h"
#include "src/IncrementalEventLearning.h"
#include "src/degumodel.h"
#include "MODELS/DeguTrackingModel.h"
#include "src/groundtruth.h"
#include "src/rectangle.h"
#include "src/templateclass.h"
#include "src/footballConstants.h"
#include "src/footballscenemodel.h"
#include "src/gtstructures.h"

class Datapool: public QObject {
    Q_OBJECT
    public:
        Datapool();
        ~Datapool();
        static QVector<QRgb> *setGrayScaleTable();
        static QVector<QRgb> *setThermalTable();
        static void deleteTables();

        void appendToLog(const QString&);
        static QString getCurrentDateTimeString();
        void pauseApp();
        void clear();
        void init();
        //Data:
        //Frame number from acquisition module
        int frameNumber;

        //Program modules configuration
        std::vector<QString> moduleSequenceNames;
        std::vector<double> moduleSequenceMSTime;
        std::vector<double> moduleSequenceMeanTime;
        std::vector<double> moduleSequenceVarTime;
        std::vector<int> moduleSequenceMinTime;
        std::vector<int> moduleSequenceMaxTime;
        double totalTime;

        long processedFrames;

        //Scene information
        SceneModel *sceneModel;
        std::map<ObjectType, SpModelInterface> objectModels;
        footballSceneModel *fSceneModel;

        //Current Image Frame
        QImage *currentImage;

        cv::Mat currentImageMat;

        cv::Mat currentImageMatYUV;

        cv::Mat currentImageMatY;

        cv::Mat fgImageMat;

        cv::Mat featureMapMat;


        QImage *previousImage;

        bool cycleActivated;

        bool firstOfCycle;

        //Variables Fredes Caro - CV 2014-1------------------------------------
        QImage *currentDepthImage;
        QImage *previousDepthImage;
        QImage *NewImage;
        QImage *NewImage2;
        ImageHeader * currentDepthHeader;
        int frameDepthNumber;
        //Fin Variables Fredes Caro - CV 2014-1------------------------------------
        QImage *skeletonImage; //Barrientos Nettle - CV 2014-1
        QImage *filteredImage; //Barrientos Nettle - CV 2014-1

        QImage *foregroundSampledImage; //Barrientos Nettle - CV 2014-1

        //Current Gray Image Frame
        QImage *grayImage;

        //Image header with date/time information
        ImageHeader *currentHeader;

        //Background Image
        QImage *bgImage;

        //Mask Image
        QImage *maskImage;

        //Calibration Matrix
        cv::Mat cameraMatrix;
        cv::Mat distCoeffs;
        std::vector<cv::Mat> rvecs;
        std::vector<cv::Mat> tvecs;

        //Reliability segmentation results

        QImage *featureMap;

        QImage *reliabilityMap;

        QImage *empiricalReliabilityMap;

        //Segmentation results
        QImage *fgImage;

        QImage *colouredFgImage;

        int *labelMatrix;

        std::map<QString, double> tunedParametersSet;

        bool tuningEnded;

        std::map<QString, double> bestParametersSet;

        bool postedBestParameters;

        //Segmentation results
        QImage *groundtruthFgImage; //Indexed8

        QImage *groundtruthImage; //Acquired ARGB32

        //Regional segmentation results
        QImage *currentDiffImage; //difference w/r to previous image in (t) and (t-1)
        QImage *previousDiffImage;//difference w/r to previous image in (t-1) and (t-2)
        QImage *rFgImage; //RGB888

        //Personality
        QImage *personalityPCAImage; //RGB888

        //RLE segments of FG image, ordered by row
        std::map<int, std::deque<RLESegment> > RLEFGImage;

        //RLE regions of FG image, ordered by labels
        std::map<int, RLERegion> RLERegions;

        //Incremental Learning Information
        miles::SpIncrementalEventLearning eventLearning;
        miles::SpLearningAttributes availableAttributes;
        std::map<unsigned long, std::map<int, miles::SpLevelData> > levelData;
        std::map<unsigned long, std::map<long int, double> > Pr;


        //MODELS

        //Football Models
        std::map< ColorModelType , gaussianMixtureColorModel> GMCmodels;
        appHistType apparienceHist;
        clusters2D_BOF clustersChroma;
        clusters1D_BOF clustersLuma;
        clusters3D_BOF clustersLuv;
        std::vector<playerCandidate> plCandidates;

        //Blob list
        std::vector<Blob> blobs;

        //Line list
        std::vector<cv::Vec2f> lines;
        std::vector<cv::Vec4i> lines2;

        //std::vector<HullModel> hulls; //Convex hull, with OpenCV classes
        //Object list
        std::deque<SpMobileObject> objects;

        std::deque<SpMobileObject2D> objects2D;
        std::deque<SpRMMMobileObject> RMMobjects;

        Groundtruth groundtruth;

        std::deque<SpHullModel> hulls;

        std::map<int, Object> fake_objects;

        //TEMP
        std::map<QString, DeguTrackingModel *> modelsToFollow;

        QImage *temporalVariance; //from temporal variance module

      //Event list
      //std::deque<Event> events;

      //OTHER GLOBAL INFORMATION:
      //Current configuration file name
      QString m_config_file;

      //Color table for grayscale image
      static QVector<QRgb> *grayScaleTable;

      //Color table for thermal image
      static QVector<QRgb> *thermalTable;

      //For Degu detection
      DeguModel *degu;

      //For Personality Module
      QImage *persoImage;

      //For Superpixel modules (to see if it will be the unique interface)
      //Buffer with labels for each pixel of the current image
      int *superpixel_labels;
      //Number of labels found on image
      int superpixel_numlabels;

      //Labels for superpixel, for each blob, plus information about the considered bounding region.
      std::vector<cv::Mat> blobSuperpixelLabels;

      std::vector<Rectangle<int> > blobSuperpixelBoundingRegion;
      std::vector<int> blobSuperpixelNumber;


      bool runModules;

      //GTModule
      std::string connectionQuery; //Contiene direccion y puerto
      std::string username;
      std::string password;
      std::string dbName;
      QList<classType> classes;
      QList<boundingBox> boxes;
      QString currentFile; //AcquisitionModule, nombre del archivo que se esta procesando.

  signals:
    void logString(QString);
    void pause();
};


#endif