paper3.h

#ifndef PAPER3_H
#define PAPER3_H
#include <map>
#include <string>
#include <QImage>
#include "Datapool.h"
#include "ModuleInterface.h"
#include <QDir>
#include "opencv2/opencv.hpp"
#include "VideoAnalysis.h"

#include <boost/random.hpp>
#include <boost/random/normal_distribution.hpp>
#define Nparticles 100
//#include <boost/random.hpp>
//#include <boost/random/normal_distribution.hpp>
#define PI 3.14159265358979323846


//Estructura de una bloob para guardarlo en una cola
// y sacar datos estadisticos
struct BlobPoint
{
    //posicion en la imagen
    int x;
    int y;
    //diferencias entre
    int delta;
    //colores correpsondientes
    uchar R,G,B;
};

//estructura de un particula del filtro de
//de particula
struct Particle
{
    //posicion
    int x;
    int y;
    //peso
    int w;
    uchar R,G,B;
};



class paper3: public ModuleInterface {

public:
    paper3(Datapool *i_data);
    ~paper3();

    //Set module configuration parameters
    bool setParameters(QDomNode& config);

    //Initialization after reading parameters
    bool init();

    //Function executed at each frame
    bool run();

    //update parameters at runtime.
    bool updateParameters();


private:

    //función para detectar diferencias relacionadas con el primer filtro que busca colores predominantes
    //el cual ademas sacaa datos estadisticos de estos puntos
    QImage Detectar_Deltas(QImage,QRgb);
    QImage currentimage_shadow;

    //conjunto de histogramas auxiliares separados porcanal
    int Histo1R[256];
    int Histo1G[256];
    int Histo1B[256];

    int Histo2R[256];
    int Histo2G[256];
    int Histo2B[256];

    //variables auxiliares para guardar imagenes
    QImage *PP;
    QImage *PP2;
    QRgb MM;


    //particle filter para color
    //colas para puntos bloob de segmentación de color(primer filtro)
    std::deque<BlobPoint> bloob;
    //colas para particulas para color
    std::vector<Particle> Particles;
    //función que acumula los pesos
    double PesosAcumulados[Nparticles] ;
    //esperanza de la distribución obtenida en la segmentación a color
    double E[2];
    //varianza de la distribución obtenida en la segmentación a color
    double V[3];
    //pinta caja asociada a la varianza y esperanza
    bool paintCaja(QImage *);
    //imagen que guarda el modelo
    QImage Model;
    //funciona para cargar la imagen
    //en esa función hay que cambiar el parametro
    void loadModel();


    //variable que guarda el cuadrado obtenido, mediante
    //valores de esperanzas y varianzas
    QRect A;

    void SeekMaxInModel();
    //maximos hallados, actualmente se
    //colocan directamente lo valores
    //pero con
    //loadModel()
    //SeekMaxInModel
    //se guardan estos maximos del modelo en:
    int MaxHistrogramModel[3];

    //funciones para las particulas
    void resample();
    int pick_base_sample();
    void CalculaPesosAcumulados();
    int BusquedaBinaria();

    void initRandomParticles();
    void PropagaEn2Niveles();
    void calculaPesosConLikelihood();

    //particle filter para profundidad
    //segmentacion
    //limpia histograma
    void VaciaHistogramaDepth();
    //llena histograma
    void llenaHistogramaDepth();
    //suaviza histograma con gaussiana
    void suavizarHistograma();
    //busca minimos locales en el histograma de
    //profundidad , entre los cuales asigna un color
    //o etiqueta
    void MinMaxLocales();
    //colaca los colores obtenidos de MinMaxLocales
    void pintaDepth();

    int HS[256];
    //histograma de profundidad
    int HistoDepth[256];
    //matriz de colores correspondiente a cada tramo de color
    //encontrado entre minimos locales
    int segColorDepth[256];
    //agrupas las funciones anteriores para en conjunto realizar
    //esta segmentacion
    void SegmentaDepth();

    //copias de la info entrante
    QImage copiaQDepth;
    cv::Mat copiaCV_Depth;
    cv::Mat copiaCV_DepthGray;

    //utilidades
    cv::Mat formatconv_QT2CV(const QImage );
    QImage formatconv_CV2QT(const cv::Mat&);

    boost::random::mt19937 rng;
    double GaussianValue(float,float,float,float,int,int,int,int);

};


#endif // PAPER3_H