VoxelGrid_Object_Data.h

Go to the documentation of this file.

#ifndef VOXELGRID_OBJECT_DATA_H
#define VOXELGRID_OBJECT_DATA_H

#include "GeometryLoaderBase.h"
#include <vrecko/Ability.h>
#include <vrecko/SP_ObjectInterface.h>

#include <helpers/BufFile.h>

#include <osg/BoundingBox>


namespace APSpacePartitioning {

class VoxelGrid_Object_Data: public vrecko::SP_Object_DataInterface, public GeometryLoaderBase, public vrecko::Ability {
public:
    VoxelGrid_Object_Data();
    ~VoxelGrid_Object_Data();

    virtual void preInitialize();
    virtual void postInitialize();
    virtual void update();

    virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node);

    virtual bool isHierarchyCreated() { return bGridCreated && bGridFilled; }

    virtual bool createHierarchy(void);
    
    inline unsigned long getXDFDim() { return dFXDim; }
    inline unsigned long getYDFDim() { return dFYDim; }
    inline unsigned long getZDFDim() { return dFZDim; }


    inline osg::BoundingBox& getBBoxDF() {return bboxDF;}
    inline float getDistanceFieldValue(int x, int y, int z){
        if (x >= dFXDim || y >= dFYDim || z >= dFZDim || x < 0 || y < 0 || z < 0) {
            return 0;
        }
        return distanceField[ x * (dFYDim * dFZDim) + y * dFZDim + z];
    }

    inline int getDistanceFieldValueEffect(unsigned long x, unsigned long y, unsigned long z, int level){
        if (getDistanceFieldValue( x, y, z) > level){
            return 0;
        } else {
            return 1;
        }
    }

    inline float getDistanceTempFieldValue(int x, int y, int z){
        if (x >= dFXDim || y >= dFYDim || z >= dFZDim || x < 0 || y < 0 || z < 0) {
            return 0;
        }
        return distanceFieldTemp[ x * (dFYDim * dFZDim) + y * dFZDim + z];
    }

    inline float getRequestedCellSize() {return dRequestedCellLength;}
    inline osg::Vec3& getBBoxDFSize() {return bboxSizeDF;}

    void VoxelGrid_Object_Data::increaseVoxelValueCollisions(int x, int y, int z){
        distanceFieldCollsions[ x * (dFYDim * dFZDim) + y * dFZDim + z]++;
    }
    void VoxelGrid_Object_Data::setVoxelValueCollisions(int x, int y, int z, int value){
        distanceFieldCollsions[ x * (dFYDim * dFZDim) + y * dFZDim + z] = value;
    }
    int VoxelGrid_Object_Data::getCollisions(int x, int y, int z){
        return distanceFieldCollsions[ x * (dFYDim * dFZDim) + y * dFZDim + z];
    }

    osg::Vec4f returnColorOfVoxel(int x, int y, int z){
        // function : (4 + log(x*10))/6.5 where x = 0 to 1 (viz. wolfram alpha)
        // gathering information around is necessary to suppress the hich frequencies in a voxel grid of collisions. 
        // high frequencies generated unreadable represenation for human (high frequencies were visible and mid range lost)
        /*
        *   used grid for filtration : 
        *
        *   |1|1|1|     |1|1|1|     |1|1|1|
        *   |1|1|1|     |1|4|1|     |1|1|1|
        *   |1|1|1|     |1|1|1|     |1|1|1|
        */
        float collisionsDetected = 0; 
        if (x > 0 && y > 0 && z > 0 && x < dFXDim && y < dFYDim && z < dFZDim){
            int c = 0;
            for (int xT = x-1; xT < x+2; xT++){
                for (int yT = y-1; yT < y+2; yT++){
                    for (int zT = z-1; zT < z+2; zT++){
                        c += getCollisions(xT,yT,zT);
                    }
                }
            }
            c += getCollisions(x,y,z) * 3;
            collisionsDetected = (float)c / 30.0;
        } else {
            collisionsDetected = (float)getCollisions(x,y,z);
        }

        float percentage = collisionsDetected/(float)iMaxCollisionsFromLoadedVoxel;
        float red = (4.0 + log(percentage*10))/6.5;
        float green = 1.0 - red;
        return osg::Vec4f(red,green,0.0,0.5);
    };

protected:
    bool bGridCreated;
    bool bGridFilled;
    bool bCollisionCreated;

    int iMaxCollisionsFromLoadedVoxel;

    int dFXDim, dFYDim, dFZDim; // dimesntion of the distanceField 

    double dRequestedCellLength; 
    int iDilatation;
    int iDilatationStrategy; // can be 0, 1, 2 - meaning 6, 18 or 26-around
    int iGenType; // 0 is Dilatation. 1 is Precise

    float* distanceField;
    float* distanceFieldTemp;
    int* distanceFieldCollsions;

    osg::BoundingBox bboxDF;
    osg::Vec3f bboxSizeDF;

    bool createDistanceFieldGrid();
    void destroyDistanceFieldGrid();

    bool createDistanceFieldTempGrid();
    void destroyDistanceFieldTempGrid();

    bool createDistanceFieldGridCollision();
    void destroyDistanceFieldGridCollision();

    inline void setDistanceFieldValue(unsigned long x, unsigned long y, unsigned long z, float newValue){
        distanceField[ x * (dFYDim * dFZDim) + y * dFZDim + z] = newValue;
    }

    inline void setDistanceFieldTempValue(unsigned long x, unsigned long y, unsigned long z, float newValue){
        distanceFieldTemp[ x * (dFYDim * dFZDim) + y * dFZDim + z] = newValue;
    }

    bool constructCacheDataName(char *pOutDataName);

    bool loadFromCache(const char *pModelFileName);
    bool saveToCache(const char *pModelFileName);

    bool loadGridFromFile(vrecko::BufferedFile *bfile);
    bool saveGridToFile(vrecko::BufferedFileWrite *bfile);

    // storing a collisions
    bool saveCollisions();
    bool saveCollisionsToFile(vrecko::BufferedFileWrite *bfile);

    bool loadCollisions();
    bool loadCollisionsFromFile(vrecko::BufferedFile *bfile);

    bool updateDataInformation(char* data, char* file);

};

} // namespace APSpacePartitioning


#endif