DistanceTransform.h

Go to the documentation of this file.

#ifndef DistanceTransform_h
#define DistanceTransform_h

#include <assert.h>
#include <float.h>
#include <limits.h>

#include <math.h>
#ifndef M_SQRT2
    #define M_SQRT2     1.41421356237309504880
#endif

#include <stdio.h>
//----------------------------------------------------------------------
class DistanceTransform {

public:
    static const int     IntInfinity;
    static const double  FloatInfinity;


    DistanceTransform    ( const int xSize, const int ySize,
                           const bool unload=true );
    virtual ~DistanceTransform   ( );

    virtual void doTransform ( const unsigned char* const I ) = 0;

    inline double getD   ( const int x, const int y ) const {
        if (dD != NULL)  return dD[sub(x,y)];
        //otherwise, use int's
        assert( iD!=NULL );
        return iD[sub(x,y)];
    }


    virtual inline bool getP ( const int x, const int y, int& px, int& py )
    const {
        px = py = -1;
        return false;
    }

protected:
    int        xSize;  
    int        ySize;  
    //calculated distance transforms (some distance transforms use int's
    // and others use double's to represent the distance values
    double*    dD;     
    int*       iD;     

    class P {
        public:
            int x;
            int y;
            inline P ( const int x, const int y ) {
                this->x = x;
                this->y = y;
            }
    };

    inline int sub ( const int x, const int y ) const {
        if (x<0 || x>=this->xSize) {
            assert( x>=0 && x<this->xSize );
        }
        if (y<0 || y>=this->ySize) {
            assert( y>=0 && y<this->ySize );
        }
        assert( rowOffsets!=NULL );
        return rowOffsets[y] + x;
    }

    template <class T>
        void initImmediate ( const unsigned char* const I, T* d,
                             const T halfDx=0, const T halfDy=0 ) {
            //initialize elements of the immediate exterior
            // & the immediate interior
            for (int y=1; y<ySize-1; y++) {
                for (int x=1; x<xSize-1; x++) {
                    if ( I[sub(x-1,y)] != I[sub(x,y)] ||
                         I[sub(x+1,y)] != I[sub(x,y)] ) {
                        if (halfDx < d[sub(x,y)])    d[sub(x,y)] = halfDx;
                    }
                    if ( I[sub(x,y-1)] != I[sub(x,y)] ||
                         I[sub(x,y+1)] != I[sub(x,y)] ) {
                        if (halfDy < d[sub(x,y)])    d[sub(x,y)] = halfDy;
                    }
                }
            }
    };

    template <class T>
        inline void check ( T* d, const int center, const int X, const int Y,
                            const T Delta ) {
            const int Near     = sub(X,Y);
            const T   possible = d[Near] + Delta;
            if (possible < d[center]) {
                d[center] = possible;
            }
    }

    virtual void borderCheck ( const unsigned char* const I );
    void cleanUp ( );
    void finish ( const unsigned char* const I, double* d );
    void finish ( const unsigned char* const I, int* d,
                  const int dx, const int dy );

private:
    int*       rowOffsets;    
    bool       unloadFlag;    
};

#endif
//----------------------------------------------------------------------

---