PointShell_Object_Data.h

Go to the documentation of this file.

#ifndef POINTSHELL_OBJECT_DATA_H
#define POINTSHELL_OBJECT_DATA_H

#include <list>
#include <vector>
#include <stack>
#include <string>

#include "PointShell_Object_Data_LOD_Builder.h"

#include "GeometryLoaderBase.h"
#include "SP_Object_Data_Base.h"
#include <vrecko/Ability.h>
#include <vrecko/Scene.h>
#include <helpers/DynamicTree.h>
#include <helpers/BufFile.h>

#include <osg/BoundingBox>
#include <osg/PolygonMode>
#include <osg/StateSet>
#include <osg/Geode>
#include <osg/ShapeDrawable>
#include <osg/Material>
#include <osg/Geometry>


#define FACE(x) ((FaceBase*)getFace(x))
#define VERTEX(x) ((VertexBase*)getVertex(x))

namespace APSpacePartitioning {

template <class _NodeType>
class PointShellGeneric_Object_Data: public GeometryLoaderBase, public SP_Object_Data_Base {
public:

    /* 
    * enumeration list of supported pointshell creatin lists
    */
    enum CreationType {
        LOD_Hierarchy,          
        Simple,                 
        ByVoxels_SingleLevel,   
        ByVoxels_MultiLevel,    
        Test                    
    };

    CreationType creationType; 
    PointShellGeneric_Object_Data(const char *abName);
    ~PointShellGeneric_Object_Data();

    virtual bool isHierarchyCreated() { return bCreated;} 
    vector<pair<osg::Vec3f,osg::Vec3f>> getPolygons(){
        vector<pair<osg::Vec3f,osg::Vec3f>> out;
        for (int p = 0 ; p < polygonsCount; p++) {
            out.push_back(make_pair(polygons[p].first,polygons[p].second));
        }
        return out;
    }
    vector<pair<osg::Vec3f,float>> getDrawSpheres(){
        vector<pair<osg::Vec3f,float>> out;
        PointShell_SimpleNode* child = treeLOD.GetRoot()->lpChild;
        while (child->lpNext){
            out.push_back(make_pair(child->pos,child->radius));
            child = child->lpNext;
        }
        return out;
    }

    virtual int getPolygonsCount(){return getFaceCount();} 
    virtual void destroyPointShells(); 
    virtual void destroyPointShell(CreationType type); 
    int getPointShellSize(){
        if (creationType == LOD_Hierarchy) {
            return treeLOD.GetCount();
        } else if (creationType == Simple){
            return treeSimple.GetCount();
        } else if (creationType == ByVoxels_SingleLevel){
            return treeSingleLevel.GetCount();
        } else if (creationType == ByVoxels_MultiLevel){
            return treeMultiLevel.GetCount();
        } 
        return NULL;
    }
    _NodeType* getRoot(){
        if (creationType == LOD_Hierarchy) {
            return treeLOD.GetRoot();
        } else if (creationType == Simple){
            return treeSimple.GetRoot();
        } else if (creationType == ByVoxels_SingleLevel){
            return treeSingleLevel.GetRoot();
        } else if (creationType == ByVoxels_MultiLevel){
            return treeMultiLevel.GetRoot();
        }
        return NULL;
 
    }

    /*
    * returns the top node (Root) of the tree by requested CreationType
    */
    _NodeType* getRoot(CreationType type) {
        if (type == Simple) {
            return treeSimple.GetRoot();
        } else if (type == LOD_Hierarchy) {
            return treeLOD.GetRoot();
        } else if (type == ByVoxels_SingleLevel){
            return treeSingleLevel.GetRoot();
        } else if (type == ByVoxels_MultiLevel){
            return treeMultiLevel.GetRoot();
        }
        return NULL;
    }
    float maxDist; 
    osg::Vec3f maxDistVect; 
    int getCollisions(int id){getNodeWithIDFromTree( treeCollisions.getRoot(), id);} 
protected:
    pair<osg::Vec3f,osg::Vec3f>* polygons; 
    int polygonsCount; 
    DynamicTree<_NodeType> treeSimple; 
    DynamicTree<_NodeType> treeLOD; 
    DynamicTree<_NodeType> treeSingleLevel; 
    DynamicTree<_NodeType> treeMultiLevel; 
    bool treeLODCreated; 
    bool treeSimpleCreated; 
    bool treeSingleLevelCreated; 
    bool treeMultiLevelCreated; 
    int rootSizeLOD; 
    int rootSizeSimple; 
    int rootSizeMulti; 
    int rootSizeSingle; 
    int rootSizeCollisions; 
    bool bCreated; 
    void buildLODTree(); 
    bool loadTreeFromFile(vrecko::BufferedFile *bfile,DynamicTree<_NodeType>* t );
    bool loadNodeFromFileRec(_NodeType *node, vrecko::BufferedFile *bfile, DynamicTree<_NodeType>* t ); // recursive load

    bool saveTreeToFile(vrecko::BufferedFileWrite *bfile,DynamicTree<_NodeType>* t );
    bool saveNodeToFileRec(_NodeType *node, vrecko::BufferedFileWrite *bfile); // recursive save

    //for testing purposes
    bool savePointShellCollisions();

    bool ready(){
        treeSimpleCreated = (treeSimple.GetCount() > 0); 
        treeLODCreated = (treeLOD.GetCount() > 0); 
        treeSingleLevelCreated = (treeSingleLevel.GetCount() > 0);
        treeMultiLevelCreated = (treeMultiLevel.GetCount() > 0);
                 
        if (creationType == LOD_Hierarchy) {
            bCreated = treeLODCreated;
        } else if ( creationType == Simple){
            bCreated = treeSimpleCreated;
        } else if ( creationType == ByVoxels_SingleLevel) {
            bCreated = treeSingleLevelCreated;
        } else if ( creationType == ByVoxels_MultiLevel) {
            bCreated = treeMultiLevelCreated;
        }

        return bCreated;
    }
    virtual bool coreHierarchyCreation(void);
};


class PointShell_SimpleNode : public DynTreeNode<PointShell_SimpleNode> {
public:
    osg::Vec3 pos;
    osg::Vec3 iNorm; // inward normal (opposite of the usual normal!)
    float radius;
    int id;
    int collisions;

    bool loadDataFromFile(vrecko::BufferedFile *bfile) {
        return
            bfile->readFloat(&pos.x()) &&
            bfile->readFloat(&pos.y()) &&
            bfile->readFloat(&pos.z()) &&
            bfile->readFloat(&iNorm.x()) &&
            bfile->readFloat(&iNorm.y()) &&
            bfile->readFloat(&iNorm.z()) &&
            bfile->readFloat(&radius) &&
            bfile->readInt(&id) && 
            bfile->readInt(&collisions);
    }

    bool saveDataToFile(vrecko::BufferedFileWrite *bfile) {
        return
            bfile->writeFloat(pos.x()) &&
            bfile->writeFloat(pos.y()) &&
            bfile->writeFloat(pos.z()) &&
            bfile->writeFloat(iNorm.x()) &&
            bfile->writeFloat(iNorm.y()) &&
            bfile->writeFloat(iNorm.z()) &&
            bfile->writeFloat(radius) &&
            bfile->writeInt(id) &&
            bfile->writeInt(collisions);
    }
};


class PointShell_Object_Data: public PointShellGeneric_Object_Data<PointShell_SimpleNode> {
public:
    PointShell_Object_Data();
    ~PointShell_Object_Data();

    virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);

    float fMaxDistance;
    float getMaximumDistance();
    int getPointShellRootSize();
    osg::Vec3f getMaximumDistanceVector();
    
    osg::Vec4f PointShell_Object_Data::getColor(int collisions){
        float percentage = (float)collisions/(float)collisionsMax;
        if (collisionsMax == 0) collisionsMax++;
        //(log(x+1)*1.4)^0.5 where x = 0 to 1
        float c = (float)collisions/(float)collisionsMax;
        // c (x) is now 0 to 1
        float cR = pow(log(c+1)*1.4,0.5);
        osg::Vec4f color;
        float red = min(cR/0.5f,1.0f);
        float green = min((1-cR)/0.5f,1.0);
        float blue = 0;
        color.set(red,green,blue,1.0);
        return color;
    }

protected:
    void createSimple(); //  simple hierarchy creation (onlu vertices are taken)
    void createLODHierarchy(); // LOD hierarchyh based on LOD Progressive Mesh decimation 
    void createSingleLevel(double minx, double miny, double minz, double velm); // unknown
    void createMultiLevel(double minx, double miny, double minz, double velm); // unknown

    // comutation of Bounding boxes for hierarchy
    void computeBBoxSheresRadius(DynamicTree<PointShell_SimpleNode>* tree);
    void computeBBoxShereRadius(PointShell_SimpleNode* node);
    
    //createds a LOD Tree from given lodbuilder
    void buildLODTree(PointShell_Object_Data_LOD_Builder* lod_builder);
    //inserting a point into a tree as a child of p.
    void insertPointsInLODTree(PointShell_Object_Data_LOD_Builder* lod_builder,PointShell_SimpleNode* p,int id);

    // save a subdivided mesh to file to not compute again
    bool loadSubDivisionMeshFromFile(vrecko::BufferedFile *bfile);
    // load a subdivided mesh
    bool saveSubDivisionMeshToFile(vrecko::BufferedFileWrite *bfile);

    int voxResolution;      // resolution of the voxel grid used when creating the PointShell SingleLevel/MultiLevel
    int spBranchingFactor;  // Controls the creation of different PointShell hierarchy levels.
                            // Size of the n-th level is "spBranchingFactor ^ n"

    // lod parameters
    float lodEdgeImporatnce;
    float lodEdgeDistanceImportance;
    float lodVertexImporatnce;
    int lodZeroLevelSize;
    bool lodMovableVertices;
    float lodPercentageZeroLevelSize;
    int lodMaxLevels;
    int lodMinimumVertices;

    // stored collisions amounth
    int collisionsTotal;
    int collisionsMax;

    struct PSpoint {
        double x,y,z;
        double a,b,c;
    };

    vector<PSpoint> voxels;
    vector<PSpoint> ordered;
    vector< vector<PSpoint> > levels;

    inline double distance_sqr(PSpoint *voxel1, PSpoint *voxel2) {
        return (pow(voxel2->x - voxel1->x, 2) + pow(voxel2->y - voxel1->y, 2) + pow(voxel2->z - voxel1->z, 2));
    }

    inline double distance(PSpoint *voxel1, PSpoint *voxel2) {
        return (sqrt(distance_sqr(voxel1, voxel2)));
    }

    bool constructPointShellCacheDataName(char *pOutDataName);
    bool constructPointShellCacheDataName(char *pOutDataName, CreationType type);
    bool constructPointShellSubdividedMeshDataName(char *pOutDataName);

    bool loadFromCache(const char *pModelFileName); // -> depending on the options there can be many caches for a single model
    bool saveToCache(const char *pModelFileName);

    virtual bool coreHierarchyCreation(void);

    // saving pointshell collisions
    bool savePointShellCollisions();
    PointShell_SimpleNode* getNodeWithIDFromTree(PointShell_SimpleNode* topNode, int ID);

    void getCollisionsFromTree(PointShell_SimpleNode* node);

};


template <class _NodeType>
PointShellGeneric_Object_Data<_NodeType>::PointShellGeneric_Object_Data(const char *abName) : GeometryLoaderBase(), SP_Object_Data_Base(abName) {
    bCreated = false;
}


template <class _NodeType>
PointShellGeneric_Object_Data<_NodeType>::~PointShellGeneric_Object_Data() {
    destroyPointShells();
    delete [] polygons;
}


template <class _NodeType>
bool PointShellGeneric_Object_Data<_NodeType>::coreHierarchyCreation(void) {

    if (!pOwner)
        return false;

    destroyPointShell(Simple);

    if (!loadGeometry((EnvironmentObject*)pOwner)) {
        logger.warningLog("PointShell generation aborted - no geometry found (Obj ID: %d).", ((EnvironmentObject*)pOwner)->getID());
        return false;
    }


    PointShell_SimpleNode* node;

    node = new PointShell_SimpleNode(); // empty root
    treeSimple.AddNode(NULL, node);

    for (unsigned long dw = 0; dw < getVertexCount(); dw++) {
        // transfer vertices into the PointShell structure
        node = new PointShell_SimpleNode();
        node->pos = ((VertexBase*)getVertex(dw))->pos;
        node->iNorm = -((VertexBase*)getVertex(dw))->normal;
        treeSimple.AddNode(treeSimple.GetRoot(), node);
    }

    //computation of maximum distance in object 
    //and storing a maximum distance of vector. 
    osg::Vec3f v1, v2;
    for (int s = 0; s < (int)getVertexCount();s++){
        v1 = ((VertexBase*)getVertex(s))->pos;
        for (int e = 0;e < (int)getVertexCount();e++){
            v2 = ((VertexBase*)getVertex(e))->pos;
            if (maxDist < (v1-v2).length2()){
                maxDist = (v1-v2).length2();
                maxDistVect.set((v1-v2).x(),(v1-v2).y(),(v1-v2).z());
            }
        }
    }
    maxDist = sqrt(maxDist);

    bCreated = true;

    return true;
}


template <class _NodeType>
void PointShellGeneric_Object_Data<_NodeType>::destroyPointShells() {
    treeSimple.Clear(true);
    treeLOD.Clear(true);
    treeSingleLevel.Clear(true);
    treeMultiLevel.Clear(true);
    
    bCreated = false;
}

template <class _NodeType>
void PointShellGeneric_Object_Data<_NodeType>::destroyPointShell(CreationType type) {
    if (type == Simple) {
        treeSimple.Clear(true);
    } else if (type == LOD_Hierarchy){
        treeLOD.Clear(true);
    } else if (type == ByVoxels_SingleLevel) {
        treeSingleLevel.Clear(true);
    } else if (type == ByVoxels_MultiLevel) {
        treeMultiLevel.Clear(true);
    } 

    bCreated = false;
}


template <class _NodeType>
bool PointShellGeneric_Object_Data<_NodeType>::loadTreeFromFile(vrecko::BufferedFile *bfile, DynamicTree<_NodeType>* t ) {
    int i;

    t->Clear(true);
    
    if (!bfile->readInt(&i) || (i != 1)) // version
        return false;

    bool b;
    if (!bfile->readBool(&b))
        return false;

    if (!b) // -> not even a root node, we are done here
        return true;

    t->AddNode(NULL, new PointShell_SimpleNode()); // simple root node

    if (!loadNodeFromFileRec(t->GetRoot(), bfile,t))
        return false;

    return true;
}


template <class _NodeType>
bool PointShellGeneric_Object_Data<_NodeType>::loadNodeFromFileRec(_NodeType *node, vrecko::BufferedFile *bfile, DynamicTree<_NodeType>* t) {

    if (!node->loadDataFromFile(bfile))
        return false;

    _NodeType *child;
    bool b;
    while (true) {
        bfile->readBool(&b);
        if (!b) // no more children
            break;

        child = new PointShell_SimpleNode();
        if (!(t->AddNode(node, child)))
        return false;

        if (!loadNodeFromFileRec(child, bfile,t))
            return false;

    }

    return true;
}


template <class _NodeType>
bool PointShellGeneric_Object_Data<_NodeType>::saveTreeToFile(vrecko::BufferedFileWrite *bfile, DynamicTree<_NodeType>* t) {
    bfile->writeInt(1); // version

    if (!(t->GetRoot())) {
        bfile->writeBool(false);
    } else {
        bfile->writeBool(true);
        if (!saveNodeToFileRec(t->GetRoot(), bfile))
            return false;
    }

    return true;
}


template <class _NodeType>
bool PointShellGeneric_Object_Data<_NodeType>::saveNodeToFileRec(_NodeType *node, vrecko::BufferedFileWrite *bfile) {
    if (!node->saveDataToFile(bfile))
        return false;

    _NodeType *child = node->lpChild;
    while (child) {
        bfile->writeBool(true); // i.e. next child exists
        saveNodeToFileRec(child, bfile);
        child = child->lpNext;
    }
    bfile->writeBool(false); // i.e. there is no next child

    return true;
}

} // namespace APSpacePartitioning


#endif