bih_node.hh

Go to the documentation of this file.

/**!
 *
 * Copyright (C) 2007 Technical University of Liberec.  All rights reserved.
 *
 * Please make a following refer to Flow123d on your project site if you use the program for any purpose,
 * especially for academic research:
 * Flow123d, Research Centre: Advanced Remedial Technologies, Technical University of Liberec, Czech Republic
 *
 * This program is free software; you can redistribute it and/or modify it under the terms
 * of the GNU General Public License version 3 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program; if not,
 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 021110-1307, USA.
 *
 *
 * $Id: bih_node.hh 1567 2012-02-28 13:24:58Z jan.brezina $
 * $Revision: 1567 $
 * $LastChangedBy: jan.brezina $
 * $LastChangedDate: 2012-02-28 14:24:58 +0100 (Tue, 28 Feb 2012) $
 *
 *
 */

#ifndef BIH_NODE_HH_
#define BIH_NODE_HH_

#include "system/system.hh"
#include "mesh/bounding_box.hh"
#include <armadillo>
#include <algorithm>
#include "input/accessors.hh"

class BIHNode {
public:

    /// count of subareas - don't change
    static const unsigned int child_count = 2;
    /// count of dimensions
    static const unsigned char dimension = 3;

    /**
     * Set leaf node.
     */
    void set_leaf(unsigned int begin, unsigned int end, double bound,unsigned int depth) {
        child_[0]=begin;
        child_[1]=end;
        bound_ = bound;
        axis_=dimension+depth;
    }

    /**
     * Set non-leaf node.
     */
    void set_non_leaf(unsigned int left, unsigned int right, unsigned int axis) {
        ASSERT(axis < dimension," ");
        ASSERT(is_leaf(), " "); // first must be leaf node (must set bound_)
        axis_=axis;
        child_[0]=left;
        child_[1]=right;
    }

    /// return true if node is leaf
    bool is_leaf() const
    { return axis_ >= dimension; }

    /// return depth of leaf node

    inline unsigned char depth() const
    {
        ASSERT( is_leaf(), "Not leaf node.");
        return axis_ - dimension;
    }

    unsigned int leaf_begin() const
    {
        ASSERT( is_leaf(), "Not leaf node.");
        return child_[0];
    }

    unsigned int leaf_end() const
    {
        ASSERT( is_leaf(), "Not leaf node.");
        return child_[1];
    }

    /**
     * Get count of elements stored in
     *
     * @return Count of elements contained in node
     */
    unsigned int leaf_size() const
    {
        ASSERT( is_leaf(), "Not leaf node.");
        return child_[1] - child_[0];
    }

    /// return axes (coordination of splitting) of inner node
    unsigned int axis() const
    {
        ASSERT(!is_leaf(), "Not in branch node.\n");
        return axis_;
    }

    double bound() const
    {
        return bound_;
    }

    /// Return index of child node.
    unsigned int child(unsigned int i_child)  const
    {
        ASSERT(!is_leaf(), "Not in branch node.\n");
        ASSERT_LESS( i_child, child_count );
        return child_[i_child];

    }
private:


    /**
     * Constructor
     *
     * Set class members
     * @param depth Depth of node in tree.
     */
    //BIHNode(unsigned int depth);

    /**
     * Set depth of node to axes_ class members
     *
     * @param depth Depth of node in tree.
     */
    void set_depth(unsigned int depth) {
        axis_ = depth + dimension;
    }

    /// child nodes indexes
    unsigned int child_[child_count];

    /**
     * A non-leaf node has two childs (left and right). Their bounding boxes are created from the bounding box of parent
     * so that in one direction the left child set max to its bound_ and the right child set its min to bound_.
     * This way we can always repcreate bounding box of every node when traversing the tree from the root.
     */
    double bound_;

    /**
     * Value stores coordination of splitting area for inner nodes or depth for leaf nodes
     *  - values 0,1,2 indicate inner node of tree and coordination of splitting area
     *  - values 3 and greater indicate leaf node of tree and store depth of node (depth = axes_ - 3)
     */
    unsigned char axis_;

};

#endif /* BIH_NODE_HH_ */