include/extension.h

Go to the documentation of this file.

#ifndef EXTENSION_H
#define EXTENSION_H

//== INCLUDES =================================================================

#include <cmath>

//== NAMESPACES ===============================================================

namespace gpufilter {

//== ENUMERATION ==============================================================

enum initcond {
    zero, 
    clamp, 
    repeat, 
    mirror 
};

//== CLASS DEFINITION =========================================================

struct _clamp {
    float operator () ( float t ) const {
        if( t < 0.f ) return 0.f;
        else if( t > 1.f ) return 1.f;
        else return t;
    }
    int operator () ( int i, int n ) const {
        if( i < 0 ) return 0;
        else if( i >= n ) return n-1;
        else return i;
    }
};

//== CLASS DEFINITION =========================================================

struct _repeat {
    float operator () ( float t ) const {
        t = fmodf(t, 1.f);
        return t < 0.f ? t + 1.f : t;
    }
    int operator () ( int i, int n ) const {
        if( i >= 0 ) return i % n;
        else return (n-1) - ((-i-1) % n);
    }
};

//== CLASS DEFINITION =========================================================

struct _mirror {
    float operator () ( float t ) const {
        t = fabs(fmodf(t, 2.f));
        return t > 1.f ? 2.f - t : t;
    }
    int operator () ( int i, int n ) const {
        _repeat r;
        i = r(i, 2*n); 
        if( i >= n ) return i = (2*n)-i-1;
        else return i;
    }
};

//== IMPLEMENTATION ===========================================================

template< class T >
T lookat( const T *in,
          const int& i,
          const int& n,
          const initcond& ic,
          const int& p = 1 ) {
    if( !in ) return (T)0;
    switch( ic ) {
    case zero:
        if( i < 0 ) return (T)0;
        else if( i >= n ) return (T)0;
        else return in[i*p];
    case clamp:
        _clamp c;
        return in[ c(i, n)*p ];
    case repeat:
        _repeat r;
        return in[ r(i, n)*p ];
    case mirror:
        _mirror m;
        return in[ m(i, n)*p ];
    }
    return (T)0;
}

template< class T >
T lookat( const T *img,
          const int& i,
          const int& j,
          const int& h,
          const int& w,
          const initcond& ic ) {
    if( !img ) return (T)0;
    switch( ic ) {
    case zero:
        if( i < 0 or j < 0 ) return (T)0;
        else if( i >= h or j >= w ) return (T)0;
        else return img[i*w+j];
    case clamp:
        _clamp c;
        return img[ c(i, h)*w + c(j, w) ];
    case repeat:
        _repeat r;
        return img[ r(i, h)*w + r(j, w) ];
    case mirror:
        _mirror m;
        return img[ m(i, h)*w + m(j, w) ];
    }
    return (T)0;
}

//=============================================================================
} // namespace gpufilter
//=============================================================================
#endif // EXTENSION_H
//=============================================================================