MeanShift.hpp

Aller à la documentation de ce fichier.

/// \file 
/// Définition des classes pour le Meanshift
#ifndef GUARD_MEANSHIFT_H
#define GUARD_MEANSHIFT_H

#include "Debug.hpp"
#include "Pixel.hpp"
#include "PNG.hpp"
#include "PixelMap.hpp"
#include "FVector.hpp"
using namespace std;

static Channel channelMeanShift(&cout);
///////////////////////////////////////////////////////////////////////////////
/// Etat des points visités par le filtre Meanshift
///////////////////////////////////////////////////////////////////////////////
enum ELATTICE_STATE{
        ELATTICE_NO_MODE,
        ELATTICE_HAS_MODE,
        ELATTICE_CANDIDATE_MODE 
};
///////////////////////////////////////////////////////////////////////////////
/// Représente une zone rectangulaire de vecteurs de Features
///
/// Données du filtre Meanshift
///////////////////////////////////////////////////////////////////////////////
class Lattice{
        /// Image représentée
        PNG image;
        /// Largeur, hauteur et taille de l'imisate
        int width, height, size;
        /// Cache des points explorés
        vector<int> visited;
        /// Valeurs d'entrée
        vector<FVector> input;
        /// Valeurs de sortie
        vector<FVector> output;
        /// Etat des point explorés
        vector<ELATTICE_STATE> state;
        
public:
        /// Crée à partir d'une image
        Lattice(PNG);
        /// Retourne la largeur
        int getWidth()const;
        /// Retourne la hauteur
        int getHeight()const;
        /// Retourne le vecteur (i, j)
        FVector getFVector(const int, const int);
        /// Retourne le résultat du filtre (i, j)
        FVector getOutputFVector(const int, const int)const;
        /// Fixe le résultat du filtre (i, j)
        void setOutputFVector(const int, const int, const FVector);
        /// Retourne l'état du vecteur (i, j)
        ELATTICE_STATE getState(int, int)const;
        /// Fixe l'état du vecteur (i, j)
        void setState(const int, const int, const ELATTICE_STATE);
};
///////////////////////////////////////////////////////////////////////////////
/// Représente la fenêtre du Meanshift
///////////////////////////////////////////////////////////////////////////////
class MeanShiftWindow{
        /// Centre de la fenêtre
        FVector center;
        /// Dimension spatial de la fenêtre
        int size;
        /// Dimension dans l'espace des couleurs
        float radius;
        /// Données de à explorer
        Lattice& lattice;
        /// Données de la fenêtre
        vector<FVector> data;
public:
        /// Construit une fenêtre pour le filtre Meanshift
        /// \param int dimesion spatial
        /// \param float dimension dans l'espace des couleurs
        /// \param Lattice& données à explorer
        MeanShiftWindow(int, float, Lattice&);
        /// Retourne une chaîne de caractères détaillée
        string toString() const;
        /// Fixe le centre de la fenêtre
        /// \param int coordonnée spatial x
        /// \param int coordonnée spatial y
        void setCenter(const int, const int);
        /// Cherche les données correspondant au centre
        void findPixel();
        /// Calcule la moyenne
        /// \return float norme entre le centre et la moyenne calculée
        float computeMean();
        /// Retourne le centre de la fenêtre
        FVector getCenter() const;
};
///////////////////////////////////////////////////////////////////////////////
/// Calcul du filtre Meanshift
///////////////////////////////////////////////////////////////////////////////
class MeanShift{
        /// Données à explorer
        Lattice lattice;
        /// Fenêtre d'exploration
        MeanShiftWindow window;
        /// Dimension spatial
        int size;
        /// Dimension dans l'espace des couleurs
        float radius;
        /// Limite pour le calcul d'un mode
        int maxIter;
        /// Limite pour le speedup
        float tol;
public:
        /// Algorithme du filtre Meanshift
        /// \param int dimension spatial
        /// \param float dimension dans l'espace des couleurs
        /// \param PNG image à filtrer
        /// \param float tolérance pour le speedup
        /// \param int maximum pour le calcul d'un mode
        MeanShift(int, float, PNG, float = 0.1, int = 30);
        /// Affiche une chaîne de caractères détaillé
        string toString() const;
        /// Trouve un mode
        /// \param int coordonnée x du mode à chercher
        /// \param int coordonnée y du mode à chercher
        void findMode(const int, const int);
        /// Calcul le filtre Meanshift
        void doFilter();
        /// Construit un graphe d'adjacence des modes calculés
        Node makeNode();
};
#endif

---