---

FImage.hpp

#ifndef __FImage__
#define __FImage__



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

#include "AnImage.hpp"

#ifdef _SSE1_USED
#include "sseUtil.h"
#else
#define SSE_PAD 4
#endif

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

int                     channel;

float*          palign;
float*          p1;
float**         data;

float*          pPlus1;
float**         dataPlus1;

float*          pMin1;
float**         dataMin1;

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[] palign; delete[] data; delete[] dataPlus1; delete[] dataMin1; p1=0; }

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

float* getData(){return p1;}

void    setAll(float val=0.0);
void    set(FImage& im); 
void    set(FImage& im, int n, int* xp, int* yp);

void    setInZeroOneBox(float minVal=0.0, float maxVal=255.0);
void    setOutZeroOneBox(float minVal=0.0, float maxVal=255.0);

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; }

inline float getHMin1(int x, int y){ return dataMin1[x][y]; }
inline void     setHMin1(int x,int y, float value){ dataMin1[x][y]= value; }

inline float getHPlus1(int x, int y){ return dataPlus1[x][y]; }
inline void     setHPlus1(int x,int y, float value){ dataPlus1[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    convolveHV(int m1, int m2, int m3, int m4, int m5);                             
void    convolveHV(int m1, int m2, int m3, int m4, int m5, int m6, int m7);

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

// Image quality
// =============

// Speckle Measure
float           sigmaMeanRatio();               // sigma/mean
float           logSigma();                     // log sigma in (DB)

// Image comparisions
float           SNR(FImage& result)     // signal to noise ratio: SNR= -10 log10(errorPLSE)
                        { return -10.0*::log( errorPLSE(result) ); }
 
float           errorPLSE(FImage& result);              // Peak Least Square Error
double  SE(FImage& result);                     // square error 
float           MSE(FImage& result)                     // mean square error or variance of an image
                        { return SE(result)/(width*height); }
float           NMSE(FImage& result);                   // normalised MSE
float           RMSE(FImage& result)                    // root MSE
                        { return ::sqrt(MSE(result)); } 
float           PSNR(FImage& result, float maxRange=255)        // max peak to noise ratio
                        { return 20*log(maxRange/RMSE(result)); }


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.