---

Copie de FImage.hpp

#ifndef __FImage__
#define __FImage__



#include <stdio.h>
#include <math.h>
#include <memory.h>

#include "AnImage.hpp"

class FImage 
{
private:
        
bool            normalisation;          // 0..1 range
int             width;
int                     height;

int                     channel;


float*          p1;
float** data;

double          PI;


public:

FImage( int w, int h );
FImage( int w, int h , float value);
FImage( AnImage* source );
FImage( AnImage* source , int achannel );
FImage( AnImage* source, bool normalized );
FImage( FImage& im);                                                            // copy

~FImage(){ delete[] data; delete[] p1; }

FImage* copy();
FImage* scaleDown(int multiplier=2);

float* getData(){return p1;}

void    set(FImage& im); 
void    set(FImage& im, int n, int* xp, int* yp);

bool isNormalized(){ return normalisation; }
inline int getWidth(){ return width; }
inline int getHeight(){ return height; }


inline float    get(int x, int y){ return data[x][y]; }
inline void     set(int x,int y, float value){ data[x][y]= value; }

float   getSafe(int x, int y);
void    setSafe(int x,int y, float value);

void    gdistance1( float value );
void    gdistance2( float value );

// compute simple operations

void    operator*=( float value );
void    operator/=( float value );
void    operator+=( float value );
void    operator-=( float value );

void    operator+=( FImage& image );
void    operator-=( FImage& image );

void    mult( float rsat );
void    limit( float rmin, float rmax );

void    convolveHV(int m1, int m2, int m3);                     // near inplace

void    inverse(float biais=0.0000001);
void    ln(float biais=1.0);
void    exp();
void    root();
void    sqr();
void    power(float value);

float   laplacian(int x, int y);
float   isometricLaplacian(int x, int y);
float   normeGradient(int x, int y, float epsilon=1e-8);


float   meanCurvature(int x, int y);
float   curvature(int x, int y);

float   gij(int i, int j, int x, int y);
float   lambdaPlus(int x,int y);
float   lambdaMinus(int x,int y);
float   normalDirection(int x, int y);
float   tangentDirection(int x, int y){ return (normalDirection(x,y)+PI/2.0); }

// central differences
float dfX_0(int x, int y);
float dfY_0(int x, int y);

float dfX_0_div2(int x, int y, int idx, int idy);                       // step demi    by averaging
float dfY_0_div2(int x, int y, int idx, int idy);

float dfX_0_div2MinMod(int x, int y, int idx, int idy); // step demi    by minmod
float dfY_0_div2MinMod(int x, int y, int idx, int idy);

float dfX_0_2(int x, int y);                                                            // step 2
float dfY_0_2(int x, int y);

// oriented differences
float dfX_p1(int x, int y);
float dfY_p1(int x, int y);
float dfX_m1(int x, int y);
float dfY_m1(int x, int y);

// second differential
float dfX2(int x, int y);
float dfY2(int x, int y);
float dfXY(int x, int y);
float dfXYc(int x, int y);

float dfX2_2(int x, int y);             // step 2
float dfY2_2(int x, int y);
float dfXY_2(int x, int y);

// third differential
float dfX3(int x, int y);
float dfY3(int x, int y);


// derivee 1 along normal
float In(int x, int y);

// derivee 2 along normal
float Inn(int x, int y);

// derivee 2 along tangent
float Iee(int x, int y);

// general diff operators
float g(int x, int y, int p=1);

float peronaMalikOperator(int x, int y);
float meanCurvatureOperator(int x, int y);
float beltramiOperator(int x, int y);

float gradCorrectiveViscosity(int x, int y);

void peronaMalikOperation(FImage& image, float coefficient);
void peronaMalikRestoration(int nIterations, float coefficient);

void geodesicPeronaMalikOperation(FImage& image, float coefficient, float cgeod);
void geodesicPeronaMalikRestoration(int nIterations, float coefficient, float cgeod);

void meanCurvatureOperation(FImage& image, float coefficient);
void meanCurvatureRestoration(int nIterations, float coefficient);

void geodesicMeanCurvatureOperation(FImage& image, float coefficient, float cgeod);
void geodesicMeanCurvatureRestoration(int nIterations, float coefficient, float cgeod);

void beltramiOperation(FImage& image, float coefficient);
void beltramiRestoration(int nIterations, float coefficient);

void geodesicBeltramiOperation(FImage& image, float coefficient, float cgeod);
void geodesicBeltramiRestoration(int nIterations, float coefficient, float cgeod);
};

#endif

Restoreinpaint sourceforge project `C++/Java Image Processing, Restoration, Inpainting Project'.

Bernard De Cuyper: Open Project Leader: Concept, design and development. Bernard De Cuyper & Eddy Fraiha 2002, 2003. Bernard De Cuyper 2004. Open and free, for friendly usage only. Modifications on Belgium ground of this piece of artistic work, by governement institutions or companies, must be notified to Bernard De Cuyper.