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>

#include "DataPoint.h"

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

        unsigned int xdim() const { return mX; }
        unsigned int ydim() const { return mY; }

        Vector<float> getData(  unsigned int aX,
                                                        unsigned int aY) const {
                return getDataPoint(aX, aY).getFlow();
        }


        int getDataCount(){return mDataCount;}
        
        float getDataPiece(float aX, float aY, unsigned int aDataIndex) const{
                newDataIndex(aX,aY);
                
                float A = getDataPiece(mCurrentX,       mCurrentY, aDataIndex);
                float B = getDataPiece(mCurrentX+1,     mCurrentY, aDataIndex);
                float C = getDataPiece(mCurrentX+1,     mCurrentY+1, aDataIndex);
                float D = getDataPiece(mCurrentX,       mCurrentY+1, aDataIndex);

                const Vector<float>& upperLeft = getPosition(mCurrentX,mCurrentY);

                float xDiff = aX - upperLeft.x();
                float yDiff = aY - upperLeft.y();

                float xCellDiff = mXCellDiff[mCurrentX];
                float yCellDiff = mYCellDiff[mCurrentY]; 

                float AD = A * yDiff / yCellDiff + D * (yCellDiff - yDiff) / yCellDiff;
                float BC = B * yDiff / yCellDiff + C * (yCellDiff - yDiff) / yCellDiff;

                return AD * xDiff / xCellDiff + BC * (xCellDiff - xDiff)/ xCellDiff;            
        }
        
        Vector<float> getFlow(float aX, float aY) const{
                /*
                A-------B
                |       |       |
                |---*   |
                |               |
                D-------C
                */      
                                
                //printf("pos(%f, %f, 0)\n",aX,aY);
                newDataIndex(aX,aY);
                
                const Vector<float>& A = getFlow(mCurrentX,     mCurrentY);
                const Vector<float>& B = getFlow(mCurrentX+1,   mCurrentY);
                const Vector<float>& C = getFlow(mCurrentX+1,   mCurrentY+1);
                const Vector<float>& D = getFlow(mCurrentX,     mCurrentY+1);

                //printf("A(%f, %f, %f)\n",A.x(),A.y(), A.z());
                //printf("B(%f, %f, %f)\n",B.x(),B.y(), B.z());
                //printf("C(%f, %f, %f)\n",C.x(),C.y(), C.z());
                //printf("D(%f, %f, %f)\n",D.x(),D.y(), D.z());

                const Vector<float>& upperLeft = getPosition(mCurrentX,mCurrentY);
//              const Vector<float>& lowerRight = getPosition(mCurrentX+1, mCurrentY +1);
                
                
                float xDiff = aX - upperLeft.x();
                float yDiff = aY - upperLeft.y();

                float xCellDiff = mXCellDiff[mCurrentX];
                float yCellDiff = mYCellDiff[mCurrentY]; 

//              float xCellDiff = lowerRight.x() - upperLeft.x();
//              float yCellDiff = lowerRight.y() - upperLeft.y(); 

                
                //printf("xDiff: %f\n",xDiff);
                //printf("yDiff: %f\n",yDiff);
                //printf("xCellDiff: %f\n",xCellDiff);
                //printf("yCellDiff: %f\n",yCellDiff);
                
                const Vector<float>& AD = A * yDiff / yCellDiff + D * (yCellDiff - yDiff) / yCellDiff;
                const Vector<float>& BC = B * yDiff / yCellDiff + C * (yCellDiff - yDiff) / yCellDiff;
                
//              const Vector<float>& result = AD * xDiff / xCellDiff + BC * (xCellDiff - xDiff)/ xCellDiff;
                //printf("result(%f, %f, %f)\n",result.x(),result.y(), result.z());
                
                return AD * xDiff / xCellDiff + BC * (xCellDiff - xDiff)/ xCellDiff;
        }

        unsigned int countDataPieces() const {
                return mDataCount;
        }       

        Vector<float> minPos() const {
                return getDataPoint(0,0).getPosition();
        }
        
        Vector<float> maxPos() const {
//              printf("maxPos %i %i\n",mX,mY);
                return getDataPoint(mX-1,mY-1).getPosition();
        }

        std::pair<float, float> getDataRange(unsigned int aDataIndex) const {
//              printf("aDataIndex: %i; countDataPieces(): %i\n",aDataIndex, countDataPieces());
                assert(aDataIndex < countDataPieces());
                return mDataRanges[aDataIndex];
        }
        
private:
        DataPoint& getDataPoint(unsigned int aX, unsigned int aY) const {
                
                if (aX>= mX) printf("aX = %i mX = %i\n",aX,mX);
                if (aY>= mY) printf("aX = %i mX = %i\n",aX,mX);

                assert(aX < mX);
                assert(aY < mY);
                return mData[aY * mX + aX];
        }

        float getDataPiece(unsigned int aX,
                                                unsigned int aY,
                                                unsigned int aDataIndex) const {
                const DataPoint& p = getDataPoint(aX, aY);
                assert(p.countDataPieces() == mDataCount);
                return p.getDataPiece(aDataIndex);
        }

        Vector<float> getPosition(unsigned int aX, unsigned int aY) const{
                return getDataPoint(aX,aY).getPosition();
        }
        
        Vector<float> getFlow(unsigned int aX, unsigned int aY) const {
                return getDataPoint(aX,aY).getFlow();
        }
                
        void newDataIndex(float aX, float aY) const{
        
                Vector<float> upperLeft = getPosition(mCurrentX,mCurrentY);
                Vector<float> lowerRight = getPosition(mCurrentX+1, mCurrentY+1);
                
                //printf("\nnewDataIndex\n");
                
                //printf("pos(%f, %f, 0)",aX ,aY);
                //printf("upperLeft(%f, %f, %f)\n",upperLeft.x(),upperLeft.y(), upperLeft.z());
                //printf("lowerRight(%f, %f, %f)\n",lowerRight.x(),lowerRight.y(), lowerRight.z());             
                
                //printf("Index: %i %i\n",mCurrentX, mCurrentY);
                
                if ((upperLeft.x()> aX)||(upperLeft.y()> aY)||(lowerRight.x()< aX)||(lowerRight.y()< aY)){//we are in another cell
                        //printf("newCell!!\n");
                        
                        while ((mCurrentX > 0) && (getPosition(mCurrentX,mCurrentY).x()> aX)){
                                mCurrentX--;
                        }
                        while ((mCurrentX < mX-2) && (getPosition(mCurrentX + 1,mCurrentY + 1).x()< aX)){
                                mCurrentX++;
                        }
                        while ((mCurrentY > 0) && (getPosition(mCurrentX,mCurrentY).y()> aY)){
                                mCurrentY--;
                        }
                        while ((mCurrentY < mY-2) && (getPosition(mCurrentX + 1,mCurrentY + 1).y()< aY)){
                                mCurrentY++;
                        }
                }
                                                                
                //upperLeft = getPosition(mCurrentX,mCurrentY);
                //lowerRight = getPosition(mCurrentX+1, mCurrentY+1);

                //printf(" Index: %i %i\n",mCurrentX, mCurrentY);       
                //printf("upperLeft(%f, %f, %f)\n",upperLeft.x(),upperLeft.y(), upperLeft.z());
                //printf("lowerRight(%f, %f, %f)\n",lowerRight.x(),lowerRight.y(), lowerRight.z());
                //printf("\n");
        }

        DataPoint* mData;
        float* mXCellDiff;
        float* mYCellDiff;
        
        mutable unsigned int mCurrentX;//needed to optimize requests in world coords.
        mutable unsigned int mCurrentY;//needed to optimize requests in world coords.

        
        typedef std::vector< std::pair<float, float> > RangeType;
        RangeType mDataRanges;

        unsigned int mX, mY;
        unsigned int mDataCount; //< Number of additional data pieces

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

#endif

---