/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/operator/CannyOperators.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 <vector>
#include <iostream>
#include <list>

#include "operator/CannyOperators.hpp"
#include "operator/ConvolveOperator/ConvolveOperator.hpp"

#include "BorderExtenderCopy.hpp"

#include "PredefinedKernel.hpp"

using namespace Millie;

inline static float convolvePosition(Image& c, int x, int y, int canal, const Kernel& kernel)
{
  if(kernel.getWidth() != kernel.getHeight())
    throw IllegalArgument("convolePosition : malmed kernel");


  int width = c.getWidth();
  int height = c.getHeight();

  int aperture = kernel.getWidth()/2;

  float v = 0;
  for(int dy=-aperture; dy<=aperture; dy++)
  {
    for(int dx=-aperture; dx<=aperture; dx++)
    {
      int xk = x + dx;
      int yk = y + dy;
      if (xk<0)
        xk=0;
      if (xk>=width)
        xk=width-1;
      if (yk<0)
        yk=0;
      if (yk>=height)
        yk=height-1;
      float vk = c.getPixel(xk,yk, canal);
      v += kernel(dx+aperture,dy+aperture) * vk;
    }
  }

  return v;
}


inline static void cannyGradient(Image & c, int x, int y, int canal, float & norme, float & angle)
{
  static const KernelSobelHorizontal sobelY;
  static const KernelSobelVertical sobelX;
  float gx = convolvePosition(c, x, y, canal, sobelX);
  float gy = convolvePosition(c, x, y, canal, sobelY);

  norme = sqrt(gx*gx+gy*gy);
  angle = 0.0f;
  if (norme>0.00f)
  {
    angle = acos(gx/ norme);
    if (gy>0.00f)
      angle = 2.0f*M_PI - angle;
  }
}

inline static bool isLocalMaxima(Image& c, int x, int y, int canal)
{
  float norme;
  float angle;
  cannyGradient(c, x, y, canal, norme, angle);

  // gradient ~= 0 => consider this is not a local maxima
  if (norme<1)
    return true;

  // gradient direction
  float gx = cos(angle);
  float gy = -sin(angle);

  // scaling
  float gmax = std::max( std::abs(gx), std::abs(gy) );
  /*gmax ne peut être nul*/
  float scale = 1.0/gmax;

  // gradient value at next position in the gradient direction
  int nx = (int) (x + gx * scale);
  int ny = (int) (y + gy * scale);
  float normen;
  float anglen;
  cannyGradient(c,nx,ny, canal, normen, anglen);

  // gradient value at previous position in the gradient direction
  int px = static_cast<int>(x - gx * scale);
  int py = static_cast<int>(y - gy * scale);
  float normep;
  float anglep;
  cannyGradient(c, px, py, canal, normep, anglep);

  // is the current gradient value a local maxima ?
  if (norme>normen && norme>normep)
    return true;

  // otherwise
  return false;
}


void Millie::cannyOperator(Image& out, const Image& c,
                          int lowThreshold,
                          int highThreshold,
                          int rayon,
                          float sigma)
{
  if(c.getNumComponents() != out.getNumComponents())
    throw IllegalArgument("cannyOperator : c.getNumComponents() != out.getNumComponents()");

  /*définition du noyau de gauss*/
  KernelGaussian gauss(rayon, sigma);

  /*définition d'un étendeur de bords pour la convolution*/
  BorderExtenderCopy beCopy;

  /*proximity kernel*/
  float f[] = {1,1,1,
               1,0,1,
               1,1,1};
  Kernel proximityKernel(3,3,1,1,f);

  int width = c.getWidth();
  int height = c.getHeight();

  /*définition d'une image de même nombre de canaux que c*/
  Image cg(c.getNumComponents());

  /*calcul de la convolution avec le noyau gaussien*/
  ConvolveOperator cOp(gauss);
  cOp.compute(cg, c, beCopy);

  if(cg.getWidth() != width || cg.getHeight() != height)
  {
    std::cerr<<"Probleme dans cannyOperator";
    throw RuntimeException("cannyOperator");
  }


  out.resize(width, height);
   for(int canal=0; canal< c.getNumComponents(); canal++)
    for (int y=0; y<height; y++)
      for (int x=0; x<width; x++)
         out.setPixel(x,y,canal,0.0f);

  std::list<std::pair<int, int> > pixels;


  // gradient thresholding
  for(int canal=0; canal< c.getNumComponents(); canal++)
  {
    pixels.resize(0);
    for (int y=0; y<height; y++)
    {
      for (int x=0; x<width; x++)
      {

        // not a local maxima -> not an edge
        if (!isLocalMaxima(cg,x,y, canal))
          continue;

        // gradient intesity
        float norme;
        float angle;
        cannyGradient(cg,x,y, canal, norme, angle);

        // low-threshold -> not an edge
        if (norme<lowThreshold)
          continue;

        // high-threshold -> is an edge
        if (norme>highThreshold)
        {
          out.setPixel(x,y, canal, 255.0f);
          continue;
        }

        // between thresholds -> "unknown state" (depends of neighbors)
        pixels.push_back(std::pair<int,int>(x,y));

      }
    }

    // edge continuation
    bool change=true;
    while(change)
    {

      // for each pixel in "unknown state"
      change=false;
      std::list<std::pair<int, int> >::iterator it;
      for(it = pixels.begin(); it != pixels.end(); )
      {
        std::pair<int,int> & xy_pair = *it;
        int x = xy_pair.first;
        int y = xy_pair.second;

        // look at the neighbors
        int v = static_cast<int>(convolvePosition(out,x,y, canal, proximityKernel));

        // if neighbors is an edge -> this pixel is also an edge
        if (v!=0)
        {
          out.setPixel(x,y,canal, 255);
          it = pixels.erase(it);
          change=true;

        }
        else
        {
          ++it;
        }
      }

    }

    // exit when no more change
  }
}

---