/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/operator/InpaintOperator.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 "InpaintOperator.hpp"

#include <cmath>
#include <iostream>

using namespace Millie;

static float absolue(float a);

inline float absolue(float a)
{
  if(a<=0)
    return -a;
  else
    return a;
}




void  InpaintOperator::compute(Image & out, const Image & c,  Image& mask)
{
  int width = c.getWidth();
  int height = c.getHeight();

  if(out.getNumComponents() != c.getNumComponents())
    throw Millie::IllegalArgument("InpaintOperator::compute");

  if(mask.getHeight() != c.getHeight() || mask.getWidth() != c.getWidth())
    throw Millie::IllegalArgument("InpaintOperator::compute");



  /*taille des vecteurs dx et dy*/
  static const int n = 8;
  static const int dx [n] =
    {
      -1,0,1,1,1,0,-1,-1
    };
  static const int dy [n]  =
    {
      -1,-1,-1,0,1,1,1,0
    };


  out = c;

  std::vector<int> contourInt1;
  std::vector<int> contourInt2;

  for(int canal = 0; canal < c.getNumComponents(); canal++)
  {

    while(true)
    {

      /*vide les listes*/
      contourInt1.clear();
      contourInt2.clear();
      //            assert(contourInt1.size() == 0);
      //            assert(contourInt2.size() == 0);
      // front-line masked/unmasked
      for (int y = 0; y < height; y++)
      {
        for (int x = 0; x < width; x++)
        {
          if (absolue(mask.getPixel(x,y, canal))<0.01)
            continue;
          for (int i = 0; i < n; i++)
          {
            int xk = x + dx[i];
            int yk = y + dy[i];
            if (xk<0 || xk>=width)
              continue;
            if (yk<0 || yk>=height)
              continue;
            if (mask.getPixel(xk,yk, canal)>0.1)
              continue;
            contourInt1.push_back(x);
            contourInt2.push_back(y);
            break;
          }
        }
      }

      // exit when no front-line
      if (contourInt1.empty())
        break;

      // isophotes continuation
      for(unsigned int j=0;j<contourInt1.size();j++)
      {
        int x = contourInt1[j];
        int y = contourInt2[j];

        mask.setPixel(x,y,canal, 0.0f);


        float value=0.0f;
        float wsum=0.0f;
        float w = 0.0f;


        for (int i = 0; i < n; i++)
        {
          int xk = x + dx[i];
          int yk = y + dy[i];
          if (xk<0 || xk>=width)
            continue;
          if (yk<0 || yk>=height)
            continue;
          if (mask.getPixel(xk,yk, canal)>0.1f)
            continue;

          // gradient
          float norme = 0;
          float angle = 0;

          InpaintOperator::gradient(c, xk, yk, canal, &norme, &angle);
          // gradient normal = isophote direction
          angle+=  M_PI /2.0f;


          // Weight of the propagation:

          // 1. dotproduct ( gradient normal . propagation vector )
          float pscal;
          pscal = cos(angle)*(static_cast<float>(dx[i])) + (-sin(angle))*(static_cast<float>(dy[i]));
          pscal/=sqrt(static_cast<float> (dx[i]*dx[i]+dy[i]*dy[i])); //ne peut pas être nul !

          // 2. gradient magnitude  (O -> omnidirectionnal)
          //                    float w = (norme)*absolue(pscal)+(1-norme)*1;
          w = norme*(absolue(pscal)-1)+1;

          value += w*c.getPixel(xk,yk, canal);
          wsum  += w;
        }

        if (wsum<=0)
        {
          std::cout<<"d "<<wsum<<std::endl;
          continue;
        }
        value/=wsum;
        // set new value
        out.setPixel(x,y, canal, static_cast<int>(value));


      }

    }

  }

}




void InpaintOperator::gradient(const Image& c, int x, int y, int canal, float * norme, float * angle)
{
  int width = c.getWidth();
  int height = c.getHeight();

  const float cst1 = (0.25f*(2-sqrt(2.0f)));
  const float cst2 = (0.5f*(sqrt(2.0f)-1.0f));

  int px = x-1;
  int nx = x+1;
  int py = y-1;
  int ny = y+1;
  if (px<0)
    px=0;
  if (nx>=width)
    nx=width-1;
  if (py<0)
    py=0;
  if (ny>=height)
    ny=height-1;

  float Ipp=c.getPixel(px,py, canal);
  float Ipc=c.getPixel(px,y, canal) ;
  float Ipn=c.getPixel(px,ny, canal);
  float Icp=c.getPixel(x,py, canal);
  float Icn=c.getPixel(x,ny, canal);
  float Inp=c.getPixel(nx,py, canal);
  float Inc=c.getPixel(nx,y, canal) ;
  float Inn=c.getPixel(nx,ny, canal);

  float IppInn = cst1*(Inn-Ipp);
  float IpnInp = cst1*(Ipn-Inp);
  float gradx = (IppInn-IpnInp-cst2*Ipc+cst2*Inc);
  float grady = (IppInn+IpnInp-cst2*Icp+cst2*Icn);

  *norme = sqrt( gradx*gradx + grady*grady );

  *angle = 0.0f;
  if (*norme>0.01f)
  {
    *angle = acos(gradx/ *norme);
    if (grady>0.01f)
      *angle = 2.0f*M_PI - *angle;
  }

  *norme/=255.0f;

}

---