---

RImage.hpp

#ifndef __RImage__
#define __RImage__



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

#include "AnImage.hpp"

#include "AbsLimiter.hpp"

class FImage;

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

int                     channel;

double*         p1;
double**        data;

double          PI;


public:

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

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

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


double* getData(){return p1;}

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

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


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

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

void    gdistance1( double value );
void    gdistance2( double value );

// compute simple operations

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

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

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

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

void    inverse(double biais=0.0000001);
void    ln(double biais=0.0);
void    exp();
void    root();
void    sqr();
void    power(double value);

double  HG(int x,int y);                // Godunov hamiltonian approximating |grad u|

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

double  TVnormCentral();
double  TVnormMinmod();                         // mostly used to preserve boundaries of image features (! is diffusive)
double  TVnorm(AbsLimiter* alimiter);           // support for less diffuse limiters

// Adaptive tv norm is reduced at edges and increased in noise
// "Adaptive Total Variation Minimizing Image Restoration", David Moroni Strong, Thesis,  UCLA 1997
double  adaptiveTVnormCentral();
double  adaptiveTVnormMinmod();                         // mostly used to preserve boundaries of image features (! is diffusive)
double  adaptiveTVnorm(AbsLimiter* alimiter);   // support for less diffuse limiters

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

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

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


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

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

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

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

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

double dfX_0_div2Limiter(AbsLimiter* limiter, int x, int y, int idx, int idy);
double dfY_0_div2Limiter(AbsLimiter* limiter, int x, int y, int idx, int idy);

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

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

// diff of ENO order 2
// "Numerical Methods for Advancing Interfaces.", Seongjai Kim, Report 2000, University of Kentucky.
double dfX_ENO2_p1(int x, int y);
double dfY_ENO2_p1(int x, int y);
double dfX_ENO2_m1(int x, int y);
double dfY_ENO2_m1(int x, int y);

// diff of Upwind ENO order 2
// "Numerical Methods for Advancing Interfaces.", Seongjai Kim, Report 2000, University of Kentucky.
double dfX_UpwindENO2(int x, int y);
double dfY_UpwindENO2(int x, int y);

// diff of ENO order 3
// "Numerical Methods for Advancing Interfaces.", Seongjai Kim, Report 2000, University of Kentucky.
double dfX_ENO3_p1(int x, int y);
double dfY_ENO3_p1(int x, int y);
double dfX_ENO3_m1(int x, int y);
double dfY_ENO3_m1(int x, int y);

// diff of Upwind ENO order 3
// "Numerical Methods for Advancing Interfaces.", Seongjai Kim, Report 2000, University of Kentucky.
double dfX_UpwindENO3(int x, int y);
double dfY_UpwindENO3(int x, int y);


// diff if WENO 3
// "An Adaptive Finit Difference Method for Traveltime and Amplitude", J Qian & W. W. Symes, Report of Rice Univ.
double dfX_WENO3_p1(int x, int y, double eps=1e-12);
double dfY_WENO3_p1(int x, int y, double eps=1e-12);
double dfX_WENO3_m1(int x, int y, double eps=1e-12);
double dfY_WENO3_m1(int x, int y, double eps=1e-12);

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

double dfX2pp(int x, int y);
double dfY2pp(int x, int y);
double dfX2pm(int x, int y);
double dfY2pm(int x, int y);
double dfX2mp(int x, int y);
double dfY2mp(int x, int y);
double dfX2mm(int x, int y);
double dfY2mm(int x, int y);

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

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

double dfX3ppp(int x, int y);
double dfY3ppp(int x, int y);
double dfX3ppm(int x, int y);
double dfY3ppm(int x, int y);
double dfX3pmm(int x, int y);
double dfY3pmm(int x, int y);
double dfX3mmm(int x, int y);
double dfY3mmm(int x, int y);


// derivee 1 along normal
double In(int x, int y);
double In(AbsLimiter* limiter, int x, int y);
double InMinmod(int x, int y);

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

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

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

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

double gradCorrectiveViscosity(int x, int y);

void peronaMalikOperation(RImage& image, double coefficient);
void peronaMalikRestoration(int nIterations, double coefficient);

void geodesicPeronaMalikOperation(RImage& image, double coefficient, double cgeod);
void geodesicPeronaMalikRestoration(int nIterations, double coefficient, double cgeod);

void meanCurvatureOperation(RImage& image, double coefficient);
void meanCurvatureRestoration(int nIterations, double coefficient);

void geodesicMeanCurvatureOperation(RImage& image, double coefficient, double cgeod);
void geodesicMeanCurvatureRestoration(int nIterations, double coefficient, double cgeod);

void beltramiOperation(RImage& image, double coefficient);
void beltramiRestoration(int nIterations, double coefficient);

void geodesicBeltramiOperation(RImage& image, double coefficient, double cgeod);
void geodesicBeltramiRestoration(int nIterations, double coefficient, double 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.