ArrayTreeNode.h

Go to the documentation of this file.

//
//  Created by Matthias Thöny on 1/11/12.
//  Copyright (c) 2012 University of Zuerich. All rights reserved.
//
#ifndef VMML_ArrayTreeNode_h
#define VMML_ArrayTreeNode_h

#include <vector>
#include "CullableSpatialKey.h"
#include "ArrayTree.h"

namespace geData {
    template <short TREESIZE, class KEYTYPE, short HALFTREESIZE>
    class ArrayTreeNode
    {
    public:
        ;
        ArrayTreeNode(int _uid = -1, int _parent = -1) {
            this->key = std::make_shared< KEYTYPE >();
            this->setBasic(_uid, _parent);
        }
        ArrayTreeNode(int _uid, std::shared_ptr<KEYTYPE> _key, int _parent){
            this->setBasic(_uid, _parent);
            this->key = std::move(_key);
        }
        ArrayTreeNode(int _uid, short _lod, int _parent){
            this->setBasic(_uid, _parent);
            this->key = std::make_shared< KEYTYPE >();
            this->setLod(_lod);
        }
        ~ArrayTreeNode() {}
        
        void clear() {
            this->setBasic(-1, -1);
        }
        
        inline void setArrayNodeProperties(int _uid, std::shared_ptr<KEYTYPE> _key, int _parent, bool _isParent){
            this->setArrayNodeProperties(_uid, _parent, _isParent);
            key = std::move(_key);
        }
        
        inline void setArrayNodeProperties(int _uid, short _lod, int _parent, bool _isParent){
            this->setArrayNodeProperties(_uid, _parent, _isParent);
            this->setLod(_lod);
        }
        
        inline void setArrayNodeProperties(int _uid, int _parent, bool _isParent){
            this->setBasic(_uid, _parent);
            parent = _isParent;
        }
        
        /* sets the childid of the node according to 
         the incoming key */
        //void setChildByKey(KEYTYPE _key, int _childid)
        void setChildByKey(std::shared_ptr< KEYTYPE > const& _key, int _childid)
        {
            // if child is a Left child
            if(this->key->getX()*2 == _key->getX()){
                if(this->key->getY()*2 == _key->getY()){
                    children[0] = _childid;
                }else{
                    children[2] = _childid;
                }
            }else{
                if(this->key->getY()*2 == _key->getY()){
                    children[1] = _childid;
                }else{
                    children[3] = _childid;
                }
            }
        }
        
        int locateKeyInChild(std::shared_ptr<KEYTYPE> const& _key){
            double powOfDiff = pow(2.0f, _key->getLod() - this->key->getLod());
            int nodesProj[HALFTREESIZE];
            for (int i = 0; i < HALFTREESIZE; i++){
                nodesProj[i] = this->key->getCoord()[i] * powOfDiff;
            }
            int sidelenghtOfChild = (int)(powOfDiff / 2.0f);
            if (nodesProj[0] <= _key->getX() && _key->getX() < nodesProj[0] + sidelenghtOfChild) {
                if (nodesProj[1] <= _key->getY() && _key->getY() < nodesProj[1] + sidelenghtOfChild) {
                    return children[0];
                }
                else {
                    return children[2];
                }
            }
            else {
                if (nodesProj[1] <= _key->getY() && _key->getY() < nodesProj[1] + sidelenghtOfChild) {
                    return children[1];
                }
                else {
                    return children[3];
                }
            }
        }
        
        inline void setLod(short _lod){
            this->key->setLod(_lod);
        }
        
        inline void setBasic(int _uid, int _parent){
            uid = _uid;
            parentID = _parent;
            parent = false;
            clearChildIndices();
        }
        
        inline std::shared_ptr< KEYTYPE > const& getKey() const{
            return this->key;
        }
        
        inline void setKey(std::shared_ptr< KEYTYPE > _key){
            this->key = std::move(_key);
        }
        
        // use (shared) pointer to avoid this
//      inline void isAvailable(bool _in){
//            this->key.isAvailable(_in);
//        }
//        
//      inline bool isAvailable(){
//            return this->key.isAvailable();
//        }
                
        inline int getUID() const { return uid; }
        inline void setUID(int _uid) { uid = _uid; }
        inline const int getChildIdx(short _childIdx) const  { return children[_childIdx]; }
        inline void setChildIdx(short _childIdx, int _idx) { children[_childIdx] = _idx; }
        inline void repairChildIdx(int _nodeid) {
            for (int i = 0; i<TREESIZE; i++){
                if(children[i] > _nodeid){
                    children[i] = children[i]-1;
                }
                if(children[i] == _nodeid){
                    std::cout << "there is a problem with the nodeids while delete" << std::endl;
                }
            }
        }
        
        inline bool isParent() const { return parent; }
        inline void isParent(bool _input){
            parent = _input;
        }
        inline void setParentID(int _parent) { parentID = _parent; }
        inline int getParentID() const { return parentID; }
        
        inline const int* getChildren() const { return children; }
        
        inline void clearChildIndices() {
            for (int i = 0; i<TREESIZE; i++){
                this->children[i] = -1;
            }
        }
        
        void print(){
            std::cout << this->uid << " | ";
            std::cout << *this->key << " | ";
            std::cout << this->parent << " | ";
            std::cout << this->parentID << " | ";
            std::cout << this->getChildIdx(0);
            for (int i = 1; i<TREESIZE; i++){
                std::cout << "," << this->getChildIdx(i);
            }
            std::cout << " | ";
        }

    protected:
        int children[TREESIZE];
        std::shared_ptr< KEYTYPE > key;
        
    private:
        int uid;
        int parentID;
        bool parent;
    };
    
    typedef ArrayTreeNode<4, geSpatial::CullableSpatialKey, 2 > ArrayQuadTreeNode;
    typedef ArrayTreeNode<2, geSpatial::BinaryTreeKey, 1 > ArrayBinTreeNode;
    
    typedef ArrayTree< ArrayQuadTreeNode > ArrayQuadTree;
    typedef ArrayTree< ArrayBinTreeNode > ArrayBinTree;
    
}
#endif