CullableSpatialKey.h

Go to the documentation of this file.

#ifndef GlobeEngine_CullableSpatialKey_H
#define GlobeEngine_CullableSpatialKey_H

#include <iostream>
#include <cassert>
#include <memory>
#include <set>
#include "SpatialKey.h"

namespace geSpatial {
    /*
     *    A culable spatial key is used if you need to 
     *    have the spatial key as cullable object but
     *    you do not have any other geometric properties
     */
    template <int D, class T> class CullableSpatialTreeKey  :  public SpatialTreeKey< D, T>
    {
    public:
        void clearCullability() {
            requestable = true;
            requestabilityTested = false;
            loaded = false;
            removed = false;
            inViewFrustum = false;
            farFromViewFrustum = false;
            cameraDistance = 0.0;
        }
        
        void isRequestable(bool _in){ this->requestable = _in; }
        
        bool isRequestable() const { return this->requestable; }
        
        void isLoaded(bool _in){ this->loaded = _in; }
        
        bool isLoaded() const { return this->loaded; }
        
        void isRemoved(bool _in){ this->removed = _in; }
        
        bool isRemoved() const { return this->removed; }
        
        void isRequestabilityTested(bool _in){ this->requestabilityTested = _in; }
        
        bool isRequestabilityTested() const { return this->requestabilityTested; }
        
        void isInViewFrustum(bool _in) { this->inViewFrustum = _in; }
        
        bool isInViewFrustum() const { return this->inViewFrustum; }
        
        void isFarFromViewFrustum(bool _in) { this->farFromViewFrustum = _in; }
        
        bool isFarFromViewFrustum() const { return this->farFromViewFrustum; }
        
        void setDistanceToCamera(double _in) { this->cameraDistance = _in; }
        
        double getDistanceToCamera() const { return this->cameraDistance; }
        
    protected:
        /* tells you if the file system was tested already for this  key. */
        bool requestabilityTested;
        
        /* tells you if a key can exist in this LoD structure. e.g. is avilable in the TMS file structure. */
        bool requestable;
        
        /* tells you if the content of a key is loaded. */
        bool loaded;
        
        /* tells you if the content of this key was deleted. */
        bool removed;
        
        /* tells you if the key is currently in view frustum or not. */
        bool inViewFrustum;
        bool farFromViewFrustum;
        /* tells you how far the key is currently from the camera. */
        double cameraDistance;
    };
    
    /*
     *    A cullable spatial key for a 2D data strcutures
     *    is used for example in a spatial quadtree
     *    where parts of the quadtree need to be requestable 
     *    and cullable based on the key properties. The keys
     *    have a priorisation based on the distance to camera
     */
    template <class T> class CullableSpatialKey2 :  public CullableSpatialTreeKey< 2, T>
    {
    public:
        CullableSpatialKey2(){
            this->setInitial(-1, -1, -1);
        }
        
        CullableSpatialKey2(short _lod) {
            this->setInitial(_lod, -1, -1);
        }
        
        CullableSpatialKey2(short _lod, unsigned int _x, unsigned int _y) {
            this->setInitial(_lod, _x, _y);
        }
        
        void setInitial(short _lod, unsigned int _x, unsigned int _y) {
            this->setLod(_lod);
            this->coord[0] = _x;
            this->coord[1] = _y;
            this->clearCullability();
        }
        
        // perform a deep copy of the spatial key
        CullableSpatialKey2(const std::shared_ptr<CullableSpatialKey2> _copy){
            this->setLod(_copy->getLod());
            this->coord[0] = _copy->getX();
            this->coord[1] = _copy->getY();
            
            this->requestabilityTested = _copy->requestabilityTested;
            this->requestable = _copy->requestable;
            this->loaded = _copy->loaded;
            this->removed = _copy->removed;
            this->parent = _copy->parent;
            for(int i=0;i<4;i++){
                this->childs[i] = _copy->childs[i];
            }
        }
        
        std::shared_ptr< CullableSpatialKey2<T> > getParentKey() {
            return this->parent;
        }
        
        std::shared_ptr< CullableSpatialKey2<T> > getChildKey(int _idx) {
            if(!childs[_idx]){
                switch (_idx) {
                    case 0:{
                        this->childs[_idx] = std::make_shared<CullableSpatialKey2<T> >(this->lod+1,this->coord[0]*2, this->coord[1]*2);
                        break; }
                    case 1:{
                        this->childs[_idx] = std::make_shared<CullableSpatialKey2<T> >(this->lod+1,this->coord[0]*2 + 1, this->coord[1]*2);
                        break; }
                    case 2:{
                        this->childs[_idx] = std::make_shared<CullableSpatialKey2<T> >(this->lod+1,this->coord[0]*2, this->coord[1]*2 + 1);
                        break; }
                    case 3:{
                        this->childs[_idx] = std::make_shared<CullableSpatialKey2<T> >(this->lod+1,this->coord[0]*2 + 1, this->coord[1]*2 + 1);
                        break; }
                    default:
                        std::cout << "Child key request out of range" << std::endl;
                        assert(false);
                        break;
                }
            }
            return childs[_idx];
        }
        
        int getChildKeyInDirectionTo(std::shared_ptr< CullableSpatialKey2<T> > _key) {
            this->getChildKey(getChildIdxInDirectionTo(_key));
        }
            
        int getChildIdxInDirectionTo(std::shared_ptr< CullableSpatialKey2<T> > _key) {
            double powOfDiff = pow(2.0f, _key->getLod() - this->getLod());
            int keysProj[2];
            for (int i = 0; i < 2; i++){
                keysProj[i] = this->getCoord()[i] * powOfDiff;
            }
            int sidelenghtOfChild = (int)(powOfDiff / 2.0f);
            if (keysProj[0] <= _key->getX() && _key->getX() < keysProj[0] + sidelenghtOfChild) {
                if (keysProj[1] <= _key->getY() && _key->getY() < keysProj[1] + sidelenghtOfChild) {
                    return 0;
                }
                else {
                    return 2;
                }
            }
            else {
                if (keysProj[1] <= _key->getY() && _key->getY() < keysProj[1] + sidelenghtOfChild) {
                    return 1;
                }
                else {
                    return 3;
                }
            }
        }
        
        /* smaller with x coordinate priority. And priority for stuff in view frustum. 
         * Shared pointers seem to have problems here.
         */
        bool operator<(const CullableSpatialKey2 &_other) const{
        //bool operator<(const std::shared_ptr< CullableSpatialKey2> _other) const {
        //bool operator<(const std::shared_ptr< CullableSpatialKey2> _other) const {
            //if(this->inViewFrustum && !other.inViewFrustum)
            //    return this->inViewFrustum;
            //if(!this->inViewFrustum && other.inViewFrustum)
            //    return this->inViewFrustum;
            /*if(this->cameraDistance > 0.0){
                return this->cameraDistance < _other.cameraDistance;
            }*/
            
            if(this->lod != _other.lod)
                return this->lod < _other.lod;
            if(this->coord[0] != _other.coord[0])
                return this->coord[0] < _other.coord[0];
            return this->coord[1] < _other.coord[1];
        }
        
        /* is equal is coordinates are equal */
        bool operator==(const CullableSpatialKey2 &other)const{
            return this->lod == other.lod && this->coord[0] == other.coord[0] && this->coord[1] == other.coord[1];
        }
        
        unsigned int getX() {  return this->coord[0];  };
        void setX(unsigned int _in) {  this->coord[0] = _in; };
        unsigned int getY() {  return this->coord[1]; };
        void setY(unsigned int _in) { this->coord[1] = _in; };
        
    private:
        std::shared_ptr< CullableSpatialKey2<T> > parent;
        std::shared_ptr< CullableSpatialKey2<T> > childs[4];
    };

    typedef CullableSpatialKey2<char> CullableSpatialKey2b;
    typedef CullableSpatialKey2<unsigned char> CullableSpatialKey2ub;
    typedef CullableSpatialKey2<short> CullableSpatialKey2s;
    typedef CullableSpatialKey2<unsigned short> CullableSpatialKey2us;
    typedef CullableSpatialKey2<int> CullableSpatialKey2i;
    typedef CullableSpatialKey2<unsigned int> CullableSpatialKey2ui;
    // Spatial Key definitions. Standard ist 2D and unsigned int
    typedef CullableSpatialKey2ui CullableSpatialKey;
    
    struct CullableSpatialKeyComp {
        template <typename T>
        bool operator()(const std::shared_ptr<T>& lhs,
                        const std::shared_ptr<T>& rhs) const {
            return (*lhs) < (*rhs);
        }
    };
    
    typedef std::set< std::shared_ptr<geSpatial::CullableSpatialKey>,geSpatial::CullableSpatialKeyComp > CullableSpatialKeySet;
    typedef std::set< std::shared_ptr<geSpatial::CullableSpatialKey>,geSpatial::CullableSpatialKeyComp > ::iterator CullableSpatialKeySetIterator;
}
#endif