GeometricBalancedArrayTreeNode.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_GeometricBalancedArrayTreeNode_h
#define VMML_GeometricBalancedArrayTreeNode_h

#include <vector>
#include "BalancedArrayTreeNode.h"

namespace geData {
    template <short TREESIZE, class KEYTYPE, short HALFTREESIZE>
    class GeometricBalancedArrayTreeNode : public BalancedArrayTreeNode<TREESIZE, KEYTYPE, HALFTREESIZE>
    {
    public:
        GeometricBalancedArrayTreeNode() {
            bounds[0] = 0.0f;
            bounds[1] = 0.0f;
            bounds[2] = 0.0f;
            bounds[3] = 0.0f;
            edgelength = 0;
            visible = false;
            midPoint.set(0.0f,0.0f);
        }
        ~GeometricBalancedArrayTreeNode() {}
        virtual void printValue() const {
            std::cout << edgelength << " ";
            std::cout << boundsIdx[0] << " ";
            std::cout << boundsIdx[1] << " ";
        }
        
        const double* getBounds() const {
            return bounds;
        }
        
        // set bound information
        void setBounds(vmml::Vector4d _bound)
        {
            this->bounds = _bound;
            this->calculateMidpoint();
        }
        
        // the bound index is the information which position a quadtree
        // leave would have if the quadtree would be complete and the lowest
        // level is used as a 2D grid.
        // TODO FIX THIS SHIT!! with this->root->getMaxDepth();
        void setBoundIndex(int _maxTreeDepth)
        {
            //int maxDepth = 15;
            int stepSizeIdx = (int)(pow(2.0, _maxTreeDepth) / pow(2.0, this->key->getLod()));
            this->setBoundsIndex(this->key->getX() * stepSizeIdx, this->key->getY() * stepSizeIdx);
        }

        vmml::Vector2d getOrigin() const {
            vmml::Vector2d pt;
            pt.set(this->bounds[0], this->bounds[2]);
            return pt;
        }
        
        vmml::Vector2d getMidpoint() const {
            return this->midPoint;
        }

        bool inside( vmml::Vector2d _coord ) const {
            double const x = _coord.x(), y = _coord.y();
            return x >= bounds[0] && x <= bounds[1] && y >= bounds[2] && y <= bounds[3];
        }
        
        int locateChildIDForCoordinates(vmml::Vector2d _coord) const {
            /* First (in DEBUG mode), ensure that we're inside the node. This
             * assert would be similar to the final assert() in the original
             * code.
             */
            assert( inside( _coord ) );

            /* Now, assume that we're inside; we can do better than the
             * original code, since we can omit a whole bunch of checks.
             */
            double const childEdge = this->edgelength * 0.5;

            double const x = _coord.x(), y = _coord.y();
            double const midX = bounds[0] + childEdge, midY = bounds[2] + childEdge;


            int index = 0;
            if( x >= midX ) index |= 1;
            if( y >= midY ) index |= 2;
            return this->children[index];

#           if 0
            double childEdge = this->edgelength / 2.0;
            if (_coord.x() >= bounds[0] && _coord.x() < bounds[0] + childEdge
                && _coord.y() >= bounds[2] && _coord.y() < bounds[2] + childEdge)
            {
                return this->children[0];
            }
            else if (_coord.x() >= bounds[0] + childEdge && _coord.x() < bounds[1]
                && _coord.y() >= bounds[2] && _coord.y() < bounds[2] + childEdge)
            {
                return this->children[1];
            }
            else if (_coord.x() >= bounds[0] && _coord.x() < bounds[0] + childEdge
                && _coord.y() >= bounds[2] + childEdge && _coord.y() < bounds[3])
            {
                return this->children[2];
            }
            else if (_coord.x() >= bounds[0] + childEdge && _coord.x() < bounds[1]
                && _coord.y() >= bounds[2] + childEdge && _coord.y() < bounds[3])
            {
                return this->children[3];
            }
            assert(false);
#           endif
        }

        double getEdgelenght() const {
            return edgelength;
        }
        
        void setEdgelenght(double _edgelength) {
            this->edgelength = _edgelength;
        }
        
        void setBoundsIndex(GLuint _min_x, GLuint _min_y) {
            boundsIdx[0] = _min_x;
            boundsIdx[1] = _min_y;
        }

        const GLuint* getBoundsIndex() const {
            return boundsIdx;
        }
        
        bool isVisible() const {
            return visible;
        }
        
        void isVisible(bool _input) {
            visible = _input;
        }

        void print() {
            BalancedArrayTreeNode<TREESIZE,KEYTYPE,HALFTREESIZE >::print();
            std::cout << this->visible << " | ";
            std::cout << this->edgelength << " | ";
            std::cout << this->boundsIdx[0] << " , ";
            std::cout << this->boundsIdx[1] << " | ";
            std::cout << this->bounds[0];
            for (int i = 1; i < 4; i++){
                std::cout << "," << this->bounds[i];
            }
            std::cout << " | ";
        }

    protected:
        
        void calculateMidpoint() {
            edgelength = this->bounds[1] - this->bounds[0];
            this->midPoint.set(this->bounds[0] + (edgelength / 2.0), this->bounds[2] + (edgelength / 2.0));
        }
        
        //double bounds[4]; // min_x/max_x min_y/max_y
        vmml::Vector4d bounds;
        GLuint boundsIdx[2];
        vmml::Vector2d midPoint;
        double edgelength;
        bool visible;
    };
    
    typedef GeometricBalancedArrayTreeNode<4, geSpatial::CullableSpatialKey, 2 > GeometricBalancedArrayQuadTreeNode;
    typedef GeometricBalancedArrayTreeNode<2, geSpatial::BinaryTreeKey, 1 > GeometricBalancedArrayBinTreeNode;
    
}
#endif