ArrayTree.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_ArrayTree_h
#define VMML_ArrayTree_h

#include <vector>
#include <iostream>

namespace geData {
    template <class NODETYPE>
    class ArrayTree
    {
    public:
        ArrayTree() {}
        ~ArrayTree() {
            nodes.clear();
        }
        
        void setRootnode(NODETYPE _node){
            this->rootnode = std::move(_node);
            this->addNode(rootnode);
        }
        
        int addNode(NODETYPE _data)
        {
            _data->setUID(nodes.size());
            nodes.push_back(std::move(_data));
            return nodes.size()-1;
        }
        
        void removeNode(NODETYPE const& _data)
        {
            // search parent node id
            int parentid = 0;
            int nodeid = _data->getUID();
            NODETYPE const& _parentkey = _data->getKey()->getParentKey();
            //std::shared_ptr<geSpatial::SpatialKey> _parentkey = _data->getKey()->getParentKey();
            if(_parentkey->getLod() > -1){
                parentid = this->locateKey(_parentkey,0);
            }
            
            if(parentid != -1){
                nodes[parentid]->setChildByKey(_data->getKey(), -1);
            }
            
            if(_data->isParent()) {
                // remove children as well?
            }
            // remove node from list and repair all UIDs because they are now not valid anymore
            if(_data->getKey()->isLoaded()){
                nodes[nodeid]->clear();
                //nodes.erase(nodes.begin()+_data->getUID());
                nodes.erase(nodes.begin() + nodeid);
                this->repairTreeUIDs(nodeid);
            }
        }
         
        void repairTreeUIDs(int _nodeid) {
            // loop over the tree from bottom to top to correct all UIDs bigger than _nodeid for -1.
            for (int i = 0; i < nodes.size();i++) {
                // 1.) correct this UID if it is wrong
                if(nodes[i]->getUID() != i) {
                    nodes[i]->setUID(i);
                }
                // check parent for debug
                if(nodes[i]->getParentID() == _nodeid) {
                    std::cout << "there is a problem with the nodeids while delete" << std::endl;
                }
                // 2.) correct the UID in Parent
                if(nodes[i]->getParentID() > _nodeid) {
                    nodes[i]->setParentID(nodes[i]->getParentID()-1);
                }
                // 3.) correct the UID off children
                // 4.) correct this UID in children
                nodes[i]->repairChildIdx(_nodeid);
            }
            //return -1;
         }

        
        /*int insertNode(NODETYPE _data)
        {
            // search parent node id
            int parentid = 0;
            int nodeid = -1;//std::numeric_limits<int>::max();
            std::shared_ptr< geSpatial::SpatialKey> _parentkey = _data->getKey()->getParentKey();
            //&& _data->getKey().getLod() > 0) {
            if(_parentkey->getLod() > -1){
                parentid = this->locateKey(_parentkey,0);
            }
            // if key is available add it to the tree
            //if(_data->isAvailable()){
                nodeid = this->addNode(_data);
                nodes[nodeid]->setParentID(parentid);
            //}
            if(parentid != -1){
                nodes[parentid]->setChildByKey(_data->getKey(), nodeid);
            }else{
                //std::cout << "this key cannot be inserted" << std::endl;
            }
            return nodeid;
        };*/
        
        //int locateKey(std::shared_ptr<geSpatial::SpatialKey> _key, int _id) {
        int locateKey(NODETYPE const& _key, int _id) {
            //std::cout << _key.getLod() << " " << _key.getX()<< " " << _key.getY() << std::endl;
            if (_key->getLod() > nodes[_id]->getKey()->getLod()) {
                int childId = nodes[_id]->locateKeyInChild(_key);
                if(childId != -1){
                    return this->locateKey(_key, childId);
                }else{
                    return -1;//std::numeric_limits<int>::max();
                }
            }else{
                return nodes[_id]->getUID();
            }
        }
        
        size_t getSize() {
            return nodes.size();
        }
        
        void print() {
            for (int i = 0; i < nodes.size();i++) {
                nodes[i]->print();
                std::cout << std::endl;
            };
        }
        
        NODETYPE const& getNodeAtIndex(int _index) const { return nodes[_index]; }
        NODETYPE const& getRoot() const { return rootnode; }
        
        /* returns the LoD which was defined as maximum for this tree */
        int getMaxLod() const { return maxLoD; }
        void setMaxLod(int _inLod) {
            maxLoD = _inLod;
        }
        
        /* returns the LoD which was defined as minimum for this tree */
        int getMinLod() const { return minLoD; }
        void setMinLod(int _inLod) { minLoD = _inLod; }
        
        /* returns the highest LoD which was loaded at this tree */
        int getMaxDynamicLod() const { return maxDynamicLoD; }
        void setMaxDynamicLod(int _inLod) { maxDynamicLoD = _inLod; }
        
    protected:
        std::vector< NODETYPE > nodes;
        NODETYPE rootnode;
        short maxDynamicLoD;
        short maxLoD;
        short minLoD;
    };
}
#endif