---

imagetoolsfiltre.H

#ifndef _IMAGESTOOLSFILTRE_H_
#define _IMAGESTOOLSFILTRE_H_

#ifdef WIN32
#include <iostream>
#else
#include <iostream.h>
#endif
using namespace std;


#include <vector>
#include <algorithm>
#include <list>
#include <iterator>

#include <math.h>


template <class T>
class ImageToolsFiltre
{
public:
  static Image<T> Filtre_Median(const Image<T> &image,const int w_size); //w size est la demi taille - 1 de la fenetre

  static Image<double> gradient_spatial(const Image<T> &image);

  static Image<T> Variance(const Image<T> &image,const int w_size); //w size est la demi taille - 1 de la fenetre

  static Image<T> Filtre_Min(const Image<T> &image,const int w_size); //w size est la demi taille - 1 de la fenetre

};

template <class T>
Image<T> ImageToolsFiltre<T>::Filtre_Median(const Image<T> &image1,const int w_size)
{

  int nbl=image1.NbRow();
  int nbc=image1.NbCol();
  Image<T> image(nbl,nbc);
  int taille= (w_size*2+1)*(w_size*2+1);
  vector<T> tab(taille);
  vector<T> tab_trie(taille);
  list<T> liste;


  int i,j,u,v,ind,med,half,deb_i=0,deb_j=0,fin_i=0,fin_j=0;
  med=(int)((taille-1)/2);
  for(i=0;i<nbc;i++)
    {
      for(j=0;j<nbl;j++)
        {
          if((i>=w_size)&&(i<nbc-1-w_size)&&(j>=w_size)&&(j<nbl-1-w_size))
          {

            ind=0;
            for(u=i-w_size;u<=i+w_size;u++)
            {
              for(v=j-w_size;v<=j+w_size;v++)
              {
                tab[ind]=image1(v,u);
                ind++;
              }
            }
            tab_trie=tab;

            sort(tab_trie.begin(),tab_trie.end());

            image(j,i)= (T)tab_trie[med];

          }
          else
          {
            /* haut gauche*/
            if((i<w_size)&&(j<w_size))
            {
              deb_i=0;
              deb_j=0;
              fin_i=w_size;
              fin_j=w_size;
            }
            /* gauche*/
            if((i<w_size)&&(j>=w_size)&&(j<nbl-1-w_size))
            {
              deb_i=0;
              deb_j=j-w_size;
              fin_i=w_size;
              fin_j=j+w_size;
            }

            /* bas gauche*/
            if((i<w_size)&&(j>=nbl-1-w_size))
            {
              deb_i=0;
              deb_j=j-w_size;
              fin_i=w_size;
              fin_j=nbl-1;
            }

            /* haut droit*/
            if((i>=nbc-1-w_size)&&(j<w_size))
            {
              deb_i=i-w_size;
              deb_j=0;
              fin_i=nbc-1;
              fin_j=j+w_size;
            }

            /* droit*/
            if((i>=nbc-1-w_size)&&(j>=w_size)&&(j<nbl-1-w_size))
            {
              deb_i=i-w_size;
              deb_j=j-w_size;
              fin_i=nbc-1;
              fin_j=j+w_size;
            }

            /* bas droit*/
            if((i>=nbc-1-w_size)&&(j>=nbl-1-w_size))
            {
              deb_i=i-w_size;
              deb_j=j-w_size;
              fin_i=nbc-1;
              fin_j=nbl-1;
            }

            /*haut*/
            if((i<nbc-1-w_size)&&(j<w_size)&&(i>=w_size))
            {
              deb_i=i-w_size;
              deb_j=0;
              fin_i=i+w_size;
              fin_j=w_size;
            }

            /*bas*/
            if((i<nbc-1-w_size)&&(j>=nbl-1-w_size)&&(i>=w_size))
            {
              deb_i=i-w_size;
              deb_j=j-w_size;
              fin_i=i+w_size;
              fin_j=nbl-1;
            }
            if(!liste.empty())
              liste.clear();


            for(u=deb_i;u<=fin_i;u++)
            {
              for(v=deb_j;v<=fin_j;v++)
              {
                liste.push_back(image1(v,u));
              }
            }

            if(liste.empty())
              cout<<"probleme"<<endl;
            liste.sort();
            half = (int)(liste.size()/2.0)+1;
            for(u=1;u<half;u++)
            {
              liste.erase(liste.begin());
            }

            image(j,i)=*liste.begin();
          }
        }
    }
  return image;
}


template <class T>
Image<double> ImageToolsFiltre<T>::gradient_spatial(const Image<T> &image1)
{
  int u,v;
  int nb_row,nb_col;
  int filtre_1[3];
  int filtre_2[3];
  nb_col=image1.NbCol();
  nb_row=image1.NbRow();

  Image<double> sortie_x1(nb_row,nb_col);
  Image<double> sortie_x2(nb_row,nb_col);
  Image<double> sortie_y1(nb_row,nb_col);
  Image<double> sortie_y2(nb_row,nb_col);

  Image<double> sortie(nb_row,nb_col);

  filtre_1[0]=1;
  filtre_1[1]=2;
  filtre_1[2]=1;

   for(u=1;u<nb_col-1;u++)
   {
   for(v=1;v<nb_row-1;v++)
   {
     sortie_x1(v,u)=(double)(filtre_1[0]*(int)image1(v-1,u)+filtre_1[1]*(int)image1(v,u)+filtre_1[2]*(int)image1(v+1,u));

     sortie_y1(v,u)=(double)(filtre_1[0]*(int)image1(v,u-1)+filtre_1[1]*(int)image1(v,u)+filtre_1[2]*(int)image1(v,u+1));
    }
   }


 for(u=1;u<nb_col-1;u++)
   {
   for(v=1;v<nb_row-1;v++)
   {
     sortie_x2(v,u)=(double)(filtre_1[0]*(int)sortie_x1(v,u-1)+filtre_1[1]*(int)sortie_x1(v,u)+filtre_1[2]*(int)sortie_x1(v,u+1));

     sortie_y2(v,u)=(double)(filtre_1[0]*(int)sortie_y1(v-1,u)+filtre_1[1]*(int)sortie_y1(v,u)+filtre_1[2]*(int)sortie_y1(v+1,u));
    }
   }


  filtre_2[0]=-1;
  filtre_2[1]=0;
  filtre_2[2]=1;

  for(u=1;u<nb_col-1;u++)
  {
    for(v=1;v<nb_row-1;v++)
    {
       sortie(v,u)=sqrt((filtre_2[0]*sortie_x2(v,u-1)+filtre_2[1]*sortie_x2(v,u)+filtre_2[2]*sortie_x2(v,u+1))*(filtre_2[0]*sortie_x1(v,u-1)+filtre_2[1]*sortie_x1(v,u)+filtre_2[2]*sortie_x1(v,u+1)) +
       (filtre_2[0]*sortie_y1(v-1,u)+filtre_2[1]*sortie_y1(v,u)+filtre_2[2]*sortie_y1(v+1,u))*(filtre_2[0]*sortie_y1(v-1,u)+filtre_2[1]*sortie_y1(v,u)+filtre_2[2]*sortie_y1(v+1,u)));
    }
  }
  return sortie;
}


template <class T>
Image<T> ImageToolsFiltre<T>::Variance(const Image<T> &image1,const int w_size)
{

        int nbl=image1.NbRow();
        int nbc=image1.NbCol();
        Image<T> image(nbl,nbc);

        double moyenne, variance, diff;
        int nbelem;

        for (int y=0,i=0; y<nbl;y++) { //Boucle sur les colonnes de l'images
                for (int x=0;  x<nbc; x++, i++) { //Boucle sur les lignes de l'images
                        moyenne = 0;
                        variance = 0;
                        nbelem = 0;

                        /* Calcul de la moyenne locale (sur la fenetre) */
                        int v,u;
                        for ( v=y-w_size; v<=y+w_size; v++) {
                                for ( u=x-w_size; u<=x+w_size; u++) {
                                        if ((v>=0) && (v<nbl) && (u>=0) && (u<nbc)) {
                                                moyenne += image(v,u);
                                                nbelem++;
                                        }
                                }
                        }

                        moyenne /= nbelem;

                        /* Calcul de la variance locale (sur la fenetre) */
                        for ( v=y-w_size; v<=y+w_size; v++) {
                                for ( u=x-w_size; u<=x+w_size; u++) {
                                        if ((v>=0) && (v<nbl) && (u>=0) && (u<nbc)) {
                                                diff = image(v,u) - moyenne;
                                                variance = diff*diff;
                                        }
                                }
                        }

                        image(y,x)= variance/nbelem;
                }
        }


    return image;
}



template <class T>
Image<T> ImageToolsFiltre<T>::Filtre_Min(const Image<T> &image1,const int w_size)
{

        int nbl=image1.NbRow();
        int nbc=image1.NbCol();
        Image<T> image(nbl,nbc);

        double valMin;
        bool first;

        for (int y=0,i=0; y<nbl;y++) { //Boucle sur les colonnes de l'images
                for (int x=0;  x<nbc; x++, i++) { //Boucle sur les lignes de l'images
                
                        first = true;

                        /* Determination de la valeur min (sur la fenetre) */
                        int v,u;
                        for ( v=y-w_size; v<=y+w_size; v++)
                                for ( u=x-w_size; u<=x+w_size; u++)
                                        if ((v>=0) && (v<nbl) && (u>=0) && (u<nbc)) {
                                                if (first) {
                                                        valMin = image(v,u);
                                                        first = false;
                                                }
                                                else
                                                        if (image(v,u)<valMin) valMin = image(v,u);
                                        }

                        /* Affectation de la valeur min à l'image résultat */
                        image (y,x) = valMin;
                }
        }

        return image;
}

#endif

---