/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/operator/NagaoOperator/NagaoLocalOperator.cpp

Aller à la documentation de ce fichier.

/******************************************************************************
 *       __    _    _   _       _       _   _____                             *
 *       | \  / |  | | | |     | |     | |  | ___|                            *
 *       |  \/  |  | | | |     | |     | |  | |_                              *
 *       |      |  | | | |     | |     | |  |  _|                             *
 *       | |\/| |  | | | |__   | |__   | |  | |__                             *
 *       |_|  |_|  |_| |____|  |____|  |_|  |____|                            *
 * __________________________________________________________________________ *
 *                 Multifunctional Library For Image Processing               *
 *                                                                            *
 *                                                                            *
 *                                                                            *
 *      (c) Copyright 2007 by Humbert Florent                                 *
 *                                                                            *
 *      This program is free software; you can redistribute it and/or modify  *
 *      it under the terms of the GNU General Public License as published by  *
 *      the Free Software Foundation; only version 2 of the License.          *
 *                                                                            *
 *      This program is distributed in the hope that it will be useful,       *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *      GNU General Public License for more details.                          *
 *                                                                            *
 *      You should have received a copy of the GNU General Public License     *
 *      along with this program; if not, write to the Free Software           *
 *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA             *
 *      02111-1307, USA.                                                      *
 ******************************************************************************/

#include "MillieStd.hpp"

#include "NagaoLocalOperator.hpp"

using namespace Millie;


inline static void computeVarianceAndAverage(std::vector<float>& vect, float & variance, float & moyenne)
{
  moyenne = getAverage(vect);

  variance = 0;

  for(unsigned int i = 0; i<vect.size(); i++)
    variance += Math::square(vect[i] - moyenne);
}



inline static int getMinimumRange(std::vector<float>& vect)
{
  if(vect.size() == 0)
    throw IllegalArgument("getMinimum");


  float mini = 0.0f;
  int range = 0;

  for(unsigned int i = 1; i<vect.size(); i++)
    if(vect[i]<mini)
    {
      mini = vect[i];
      range = i;
    }

  return range;
}

NagaoLocalOperator::NagaoLocalOperator(const NagaoLocalOperator& origine)
    : LocalAreaOperator(origine)
{
  _vectKernel.resize(origine._vectKernel.size());

  for(unsigned int i=0; i<_vectKernel.size(); i++)
   _vectKernel[i] = new Kernel(*origine._vectKernel[i]);
}

NagaoLocalOperator* NagaoLocalOperator::clone() const
{
  return new NagaoLocalOperator(*this);
}


NagaoLocalOperator::NagaoLocalOperator() :
    LocalAreaOperator(2,2,2,2)
{

  float a [] =
    {
      1,1,0,
      1,1,1,
      0,1,1
    };

  Kernel* ka = new Kernel(3,3,2,2,a);

  float e [] =
    {
      1,1,1,
      1,1,1,
      0,1,0
    };

  Kernel* ke = new Kernel(3,3,1,2,e);

  float b [] =
    {
      0,1,1,
      1,1,1,
      1,1,0
    };

  Kernel* kb = new Kernel(3,3,0,2,b);

  float h [] =
    {

      1,1,0,
      1,1,1,
      1,1,0
    };


  Kernel* kh = new Kernel(3,3,2,1,h);

  float f [] =
    {

      0,1,1,
      1,1,1,
      0,1,1

    };
  Kernel* kf = new Kernel(3,3,0,1,f);

  float d[] =
    {


      0,1,1,
      1,1,1,
      1,1,0
    };
  Kernel* kd = new Kernel(3,3,2,0,d);

  float g[] =
    {

      0,1,0,
      1,1,1,
      1,1,1
    };
  Kernel* kg = new Kernel(3,3,1,0,g);

  float c[] =
    {

      1,1,0,
      1,1,1,
      0,1,1
    };

  Kernel* kc = new Kernel(3,3,0,0,c);


  _vectKernel.push_back(ka);
  _vectKernel.push_back(kb);
  _vectKernel.push_back(kc);
  _vectKernel.push_back(kd);
  _vectKernel.push_back(ke);
  _vectKernel.push_back(kf);
  _vectKernel.push_back(kg);
  _vectKernel.push_back(kh);
}

NagaoLocalOperator::~NagaoLocalOperator()
{
  for(unsigned int i = 0; i< _vectKernel.size(); i++)
  {
    delete _vectKernel[i];
    _vectKernel[i] = 0;
  }
  _vectKernel.clear();
}

float NagaoLocalOperator::computeLocalArea(const Image& image, int i, int j, int canal)
{


  /*stocke toutes les valeurs de l'image là ou le noyau vaut 1 à un position donnée*/
  std::vector<float> allKernelValue;

  /*stocke toutes les variances pour tous les noyaux à une position donnée*/
  std::vector<float> allVariance;

  /*stocke toutes les moyennes pour tous les noyaux à une position donnée*/
  std::vector<float> allAverage;

  allVariance.resize(0);
  allAverage.resize(0);

  for(unsigned int vectKerneli = 0; vectKerneli < _vectKernel.size(); vectKerneli++)
  {
    allKernelValue.resize(0);
    const Kernel& currentKernel = *_vectKernel[vectKerneli];

    for(int kj =0; kj< currentKernel.getHeight(); kj++)
      for(int ki = 0; ki< currentKernel.getWidth(); ki++)
      {
        /*si le masque vaut 1 à cette position, on enregistre le pixel*/
        if(currentKernel(ki, kj) == 1)
          allKernelValue.push_back(
            image.getPixel(i-currentKernel.getXOrigin() + ki,
                           j-currentKernel.getYOrigin() + kj,
                           canal));
      }

    /*on enregistre la variance et la moyenne pour tous ces pixels*/
    float variance;
    float moyenne;
    computeVarianceAndAverage(allKernelValue, variance, moyenne);
    allVariance.push_back(variance);
    allAverage.push_back(moyenne);
  }

  /*on détermine le noyau pour lequel la variance est minimal*/
  int range = getMinimumRange(allVariance);

  /*on écrit le pixel correspondant à la moyenne du noyau ayant
   * la plus petite variance
   */
  return allAverage[range];
}

---