Data.h

Go to the documentation of this file.

// vim:set ts=4 sw=4 noet cin:

#ifndef DATA_H_
#define DATA_H_

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

class Data {
public:
        Data(const std::string& aFilename);
        ~Data();

        // Sizes in x/y/z dimension
        unsigned short xdim() const { return mX; }
        unsigned short ydim() const { return mY; }
        unsigned short zdim() const { return mZ; }

        unsigned short getData(unsigned int aX,
                                unsigned int aY,
                                unsigned int aZ) const {
                assert(aX < mX);
                assert(aY < mY);

        //      if (aZ >= mZ) printf("aZ: %i; mZ: %i\n",aZ,mZ);
                assert(aZ < mZ);

                const unsigned int Ystride = mX;
                const unsigned int Zstride = Ystride * mY;

                return mData[aZ * Zstride + aY * Ystride + aX];

        }
        
        unsigned short getData_RangeCheck(int aX, int aY, int aZ){
                
        //      printf("%ix%ix%i\n",aX,aY,aZ);
                if ((aX<0) || (aX>=mX)) return 0;
                if ((aY<0) || (aY>=mY)) return 0;
                if ((aZ<0) || (aZ>=mZ)) return 0;

//              return getData((unsigned int) aX, (unsigned int) aY, (unsigned int) aZ);
                const unsigned int Ystride = (unsigned int) mX;
                const unsigned int Zstride = (unsigned int) Ystride * mY;

                return mData[aZ * Zstride + aY * Ystride + aX];         
        }
        
        unsigned short getDataTrilinearInterpolated(float aX, float aY, float aZ){
/*
Trilinear interpolation. cube-corners:
  E-----F
 /|    /| 
A-----B |                               Y  Z
| H---|-G                               | /
|/        |/                            |/
D-----C                                 ---X

1.Step: 4 * interpolate Z-Pos.
2.Step: 2 * interpolate Y-Pos.
3.Step: 1 *     interpolate X-Pos.

*/
                        
        //      printf("Input: %f %f %f\n",aX,aY,aZ);
                int lowerX = (int) floor(aX);
                int lowerY = (int) floor(aY);
                int lowerZ = (int) floor(aZ);
                int upperX = lowerX+1;
                int upperY = lowerY+1;
                int upperZ = lowerZ+1;
        //      printf("Output: %i %i %i\n", lowerX,lowerY,lowerZ);
        //define cube corners:
                unsigned short A = getData_RangeCheck(lowerX, upperY, lowerZ);
                unsigned short B = getData_RangeCheck(upperX, upperY, lowerZ);          
                unsigned short C = getData_RangeCheck(upperX, lowerY, lowerZ);
                unsigned short D = getData_RangeCheck(lowerX, lowerY, lowerZ);

                unsigned short E = getData_RangeCheck(lowerX, upperY, upperZ);
                unsigned short F = getData_RangeCheck(upperX, upperY, upperZ);
                unsigned short G = getData_RangeCheck(upperX, lowerY, upperZ);
                unsigned short H = getData_RangeCheck(lowerX, lowerY, upperZ);
        
                float floatX = aX - lowerX;
                float floatY = aY - lowerY;
                float floatZ = aZ - lowerZ;
        //      printf("Floats: %f %f %f\n\n",floatX,floatY,floatZ);            

//      1.Step:
                float AE = E * floatZ + A * (1-floatZ);
                float BF = F * floatZ + B * (1-floatZ);
                float CG = G * floatZ + C * (1-floatZ);
                float DH = H * floatZ + D * (1-floatZ);
//      2.Step:
                float AEDH = AE * floatY + DH * (1-floatY);
                float BFCG = BF * floatY + CG * (1-floatY);
//      3.Step:
                return (unsigned short) (BFCG * floatX + AEDH * (1-floatX));
        }

private:
        unsigned short* mData;

        unsigned short mX, mY, mZ;

        // Not to be implemented
        Data(const Data& other);
};

#endif

---