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

using namespace Millie;





float Millie::diffDx(const Image& in, int x, int y, int canal)
{
  int width = in.getWidth();

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

  return((in.getPixel(nx,y,canal) - in.getPixel(px,y,canal))/2.0f);
}

float Millie::diffDxminmod(const Image & in, int x, int y, int canal)
{
  float fx= 0.0f;

  float dplus= diffDxP(in, x, y, canal);
  float dmoins= diffDxN(in,  x, y, canal);

  fx= Math::minmod( dmoins, dplus );

  return fx;
}

float Millie::diffDyminmod(const Image & in, int x, int y, int canal)
{
  float fy= 0.0f;

  float dmoins= diffDyP(in, x, y, canal);
  float dplus= diffDyN(in, x, y, canal);

  fy= Math::minmod( dmoins, dplus );

  return fy;
}

float Millie::diffDxN(const Image & in, int x, int y, int canal)
{
  int width = in.getWidth();
  if (x+1>=width)
    return 0;

  return(in.getPixel(x+1, y, canal) - in.getPixel(x,y,canal));
}

float Millie::diffDxP(const Image & in, int x, int y, int canal)
{
  if(x-1<0)
    return 0;
  return(in.getPixel(x, y, canal) - in.getPixel(x-1,y,canal));
}

float Millie::diffDy(const Image& in, int x, int y, int canal)
{
  int height = in.getHeight();

  int py = y-1;
  int ny = y+1;

  if (py<0)
    py=0;
  if (ny>=height)
    ny=height-1;

  return (in.getPixel(x,ny,canal) - in.getPixel(x,py,canal))/2.0f;
}

float Millie::diffDyN(const Image & in, int x, int y, int canal)
{
  int height = in.getHeight();
  if (y+1>=height)
    return 0;

  return(in.getPixel(x, y+1, canal) - in.getPixel(x,y,canal));
}

float Millie::diffDyP(const Image & in, int x, int y, int canal)
{
  if(y-1<0)
    return 0;
  return(in.getPixel(x, y, canal) - in.getPixel(x,y-1,canal));
}

float Millie::diffDxx(const Image& in, int x, int y, int canal)
{
  int width = in.getWidth();

  int px = x-1;
  int nx = x+1;
  if (px<0)
    px=0;
  if (nx>=width)
    nx=width-1;
return (in.getPixel(nx,y,canal) + in.getPixel(px,y,canal) -2.0f * in.getPixel(x,y, canal));
}


float Millie::diffDyy(const Image& in, int x, int y, int canal)
{
  int height = in.getHeight();

  int py = y-1;
  int ny = y+1;

  if (py<0)
    py=0;
  if (ny>=height)
    ny=height-1;

  return (in.getPixel(x,ny,canal) + in.getPixel(x,py,canal) -2.0f * in.getPixel(x,y, canal));
}



float Millie::diffDnnC(const Image& in, int x, int y, int canal)
{
  float fx   = diffDx(in, x,y, canal);
  float fy   = diffDy(in, x,y, canal);


  float squareGradN = diffSquareGradN(in, x,y, canal);


  float fx_grad_carre;
  float fy_grad_carre;
  float fxy_grad_carre;


  fx_grad_carre = (fx * fx)/ squareGradN;
  fy_grad_carre =  (fy * fy) / squareGradN;
  fxy_grad_carre = (fx * fy) / squareGradN;


  float lambda0 = 0.5;
  float lambda1 = 2.0*lambda0 - fx_grad_carre;
  float lambda2 = 2.0*lambda0 - fy_grad_carre;
  float lambda3 = 0.5 * (-fxy_grad_carre + 1.0 - (2.0 * lambda0));
  float lambda4 = 0.5 * (1.0 - (2.0 * lambda0) + fxy_grad_carre);

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

  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;

  return   ((     lambda4 * in.getPixel(px,py, canal)
                  + lambda2 * in.getPixel(x  ,py, canal)
                  + lambda3 * in.getPixel(nx,py, canal)
                  + lambda1 * in.getPixel(px,y, canal)
                  - 4 * lambda0 * in.getPixel(x  ,y, canal)
                  + lambda1 * in.getPixel(nx,y, canal)
                  + lambda3 * in.getPixel(px,ny, canal)
                  + lambda2 * in.getPixel(x  ,ny, canal)
                  + lambda4 * in.getPixel(nx,ny, canal)));

}

float Millie::diffDntntC(const Image& in, int x, int y, int canal)
{
  float fx   = diffDx(in, x,y, canal);
  float fy   = diffDy(in, x,y, canal);



  float squareGradN = diffSquareGradN(in, x, y, canal);


  float fx_grad_carre;
  float fy_grad_carre;
  float fxy_grad_carre;

  if(squareGradN<0.01f)
    return 0;

  fx_grad_carre = (fx * fx)/ squareGradN ;
  fy_grad_carre =  (fy * fy) / squareGradN ;
  fxy_grad_carre = (fx * fy) / squareGradN ;


  float lambda0 = 0.5;
  float lambda1 = 2.0*lambda0 - fx_grad_carre;
  float lambda2 = 2.0*lambda0 - fy_grad_carre;
  float lambda3 = 0.5 * (-fxy_grad_carre + 1.0 - (2.0 * lambda0));
  float lambda4 = 0.5 * (1.0 - (2.0 * lambda0) + fxy_grad_carre);

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

  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;

  return   ((     lambda4 * in.getPixel(px,py, canal)
                  + lambda2 * in.getPixel(x  ,py, canal)
                  + lambda3 * in.getPixel(nx,py, canal)
                  + lambda1 * in.getPixel(px,y, canal)
                  - 4 * lambda0 * in.getPixel(x  ,y, canal)
                  + lambda1 * in.getPixel(nx,y, canal)
                  + lambda3 * in.getPixel(px,ny, canal)
                  + lambda2 * in.getPixel(x  ,ny, canal)
                  + lambda4 * in.getPixel(nx,ny, canal)));
}


float Millie::diffDxy(const Image& in, int x, int y, int canal)
{
  int width = in.getWidth();
  int height = in.getHeight();

  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;

  return 0.25 * (in.getPixel(nx, ny, canal) + in.getPixel(px, py, canal)
                - in.getPixel(px, ny, canal) - in.getPixel(nx, py, canal));
}



float Millie::diffGradN(const Image& in, int x, int y, int canal)
{
  return std::sqrt(Math::square(diffDx(in, x, y, canal)) + Math::square(diffDy(in, x, y, canal)));
}

float Millie::diffGradNminmod(const Image& in, int x, int y, int canal)
{
  return sqrt(Math::square(diffDxminmod(in, x, y, canal)) + Math::square(diffDyminmod(in, x, y, canal)));
}

float Millie::diffLaplace(const Image& in, int x, int y, int canal)
{
  return(diffDxx(in, x, y, canal) + diffDyy(in, x, y, canal));
}

float Millie::diffSquareGradN(const Image& in, int x, int y, int canal)
{
  return Math::square(diffDx(in, x, y, canal)) + Math::square(diffDy(in, x, y, canal));
}

float Millie::diffDnn(const Image& in, int x, int y, int canal)
{
  float norme = diffSquareGradN(in, x,y, canal);
 /* if(norme<0.001f)
    return 0.0f;
*/
  float dx = diffDx(in, x, y, canal);
  float dy = diffDy(in, x, y, canal);
  float dxx = diffDxx(in, x, y, canal);
  float dyy = diffDyy(in, x, y, canal);
  float dxy = diffDxy(in, x, y, canal);
  float temp =Math::square(dx) * dxx +Math::square(dy) * dyy
               + 2.0 * dx * dy * dxy;
  return (temp/(norme+1e-8));
}



float Millie::diffDntnt(const Image& in, int x, int y, int canal)
{
  float norme = diffSquareGradN(in, x,y, canal);
  if(norme<0.001f)
    return 0.0f;

  float dx = diffDx(in, x, y, canal);
  float dy = diffDy(in, x, y, canal);
  float dxx = diffDxx(in, x, y, canal);
  float dyy = diffDyy(in, x, y, canal);
  float dxy = diffDxy(in, x, y, canal);
  float temp = Math::square(dx) * dxx + Math::square(dy) * dyy
               - 2.0 * dx * dy * dxy;
  return (temp/norme);
}

---