include/shape/octree_node.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * Node
 * 2008-03-21
 * Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_octree_node_hpp
# define shape_octree_node_hpp

# include <iostream>
# include <list>
# include <shape/bcell.hpp>
# define Node octree_node<Object, CELL>
//====================================================================
namespace mmx {
namespace shape {

template <class Object, class CELL> class octree_node
{
public:
    enum FACE_TYPE { B, F, W, E, S, N } ;
    enum NODE_TYPE { B_SW, F_SW, B_SE, F_SE, B_NW, F_NW, B_NE, F_NE } ;
    enum EDGE_TYPE { B_E, B_W, B_S, B_N, F_E, F_W, F_S, F_N, S_E, N_E, S_W, N_W } ; 

public:
    octree_node(void) ;
    octree_node(Object object, CELL cl) ;
    octree_node(NODE_TYPE nodeType, Node * parent, CELL & cl) ;
    octree_node(Node * left, Node * right, CELL cl) ;

protected:
    octree_node(Node& node) ;

public:    
    inline void setCell(const CELL & c) { m_cell = c ; }
    
    inline void setParent(Node * n) { m_parent = n ; }
    
    inline void setFNEchild(Node * n) { F_NEchild = n ; }
    inline void setFNWchild(Node * n) { F_NWchild = n ; }
    inline void setFSEchild(Node * n) { F_SEchild = n ; }
    inline void setFSWchild(Node * n) { F_SWchild = n ; } 
    
    inline void setBNEchild(Node * n) { B_NEchild = n ; } 
    inline void setBNWchild(Node * n) { B_NWchild = n ; } 
    inline void setBSEchild(Node * n) { B_SEchild = n ; } 
    inline void setBSWchild(Node * n) { B_SWchild = n ; } 
  
                inline const CELL& get_cell(void) const { return m_cell; } 
    inline CELL & get_cell(void) { return m_cell ; }


    inline Object object(void) { return m_objects.front() ; }

    inline NODE_TYPE type(void) { return m_type ; }
    
    inline Node * FNEchild(void) { return F_NEchild ; }
    inline Node * FNWchild(void) { return F_NWchild ; }
    inline Node * FSEchild(void) { return F_SEchild ; }
    inline Node * FSWchild(void) { return F_SWchild ; } 
    
    inline Node * BNEchild(void) { return B_NEchild ; } 
    inline Node * BNWchild(void) { return B_NWchild ; } 
    inline Node * BSEchild(void) { return B_SEchild ; } 
    inline Node * BSWchild(void) { return B_SWchild ; }

    inline Node *  left(void) { return F_NWchild ; }
    inline Node * right(void) { return F_NEchild ; }
    
                bool isLeaf(void) const;
                size_t leafDistance() const;

public:   
    CELL              m_cell ;
    std::list<Object> m_objects ;
    NODE_TYPE         m_type ;
    
    Node * m_parent  ;   
    Node * F_NEchild ; 
    Node * F_NWchild ;
    Node * F_SEchild ;
    Node * F_SWchild ;
    Node * B_NEchild ;
    Node * B_NWchild ; 
    Node * B_SEchild ; 
    Node * B_SWchild ; 
    
    int depth ;
    int index ;
} ;

//--------------------------------------------------------------------
template<class Object, class CELL> Node::octree_node(void)
{ 
    m_type   = F_NE ;
    m_parent = NULL ;
    m_cell   = NULL ;

    F_NEchild = NULL ; F_NWchild = NULL ; F_SEchild = NULL ; F_SWchild = NULL ;
    B_NEchild = NULL ; B_NWchild = NULL ; B_SEchild = NULL ; B_SWchild = NULL ;

    depth = 0;
    index = 0;
} 

template<class Object, class CELL> Node::octree_node(Object object, CELL cl)
{ 
    this->m_type   = F_NE ;
    this->m_parent = NULL ;
    this->m_cell   = cl ;
    m_objects.push_back(object) ;

    F_NEchild = NULL ; F_NWchild = NULL ; F_SEchild = NULL ; F_SWchild = NULL;
    B_NEchild = NULL ; B_NWchild = NULL ; B_SEchild = NULL ; B_SWchild = NULL;

    depth = 0;
    index = 0;
} 

template <class Object, class CELL> Node::octree_node(Node * left, Node * right, CELL cl)
{
    this->m_parent = NULL ;
    this->m_cell   = cl ;

    left->type  = F_NW ;  left->parent = this ; F_NWchild =  left ;
    right->type = F_NE ; right->parent = this ; F_NEchild = right ;

    F_NWchild = left  ; F_SWchild = NULL ;
    F_NEchild = right ; F_SEchild = NULL ;
    B_NEchild = NULL  ; B_NWchild = NULL ; 
    B_SEchild = NULL  ; B_SWchild = NULL ;

    depth = left->depth-1 ;
}

template <class Object, class CELL> Node::octree_node(NODE_TYPE type, Node * parent, CELL & cl)
{  
    this->m_cell = cl ;
    this->m_type = type ; 
    this->m_parent = parent ;

    F_NEchild = NULL ; F_NWchild = NULL ; 
    F_SEchild = NULL ; F_SWchild = NULL ; 
    B_NEchild = NULL ; B_NWchild = NULL ; 
    B_SEchild = NULL ; B_SWchild = NULL ; 

    depth = parent->depth+1 ;

    switch(type) { 
    case F_NE: parent->setFNEchild(this) ; break ; 
    case F_NW: parent->setFNWchild(this) ; break ; 
    case F_SW: parent->setFSWchild(this) ; break ; 
    case F_SE: parent->setFSEchild(this) ; break ;
    case B_NE: parent->setBNEchild(this) ; break ;  
    case B_NW: parent->setBNWchild(this) ; break ;  
    case B_SW: parent->setBSWchild(this) ; break ;  
    case B_SE: parent->setBSEchild(this) ; break ; 
    default: std::cerr << "Error : the node's type isn't appropriate \n" ; break ;
    }
}

template<class Object, class CELL> bool Node::isLeaf(void) const
{
    if((F_NEchild == NULL) && (F_NWchild == NULL) &&
       (F_SEchild == NULL) && (F_SWchild == NULL) && 
       (B_NEchild == NULL) && (B_NWchild == NULL) &&
       (B_SEchild == NULL) && (B_SWchild == NULL) )
        return true; 
    return false; 
} 

template<class Object, class CELL> size_t Node::leafDistance(void) const
{
        if ( this->isLeaf() )
                return 0;

        struct inner {
                size_t operator()( const Node* node ) {
                        if ( node == 0 )
                                return 0;
                        else
                                return node->leafDistance();
                }
        } I;

        size_t d = 0;
        d = std::min( d, I(B_NEchild) );
        d = std::min( d, I(B_NWchild) );
        d = std::min( d, I(B_SEchild) );
        d = std::min( d, I(B_SWchild) );
        d = std::min( d, I(F_NEchild) );
        d = std::min( d, I(F_NWchild) );
        d = std::min( d, I(F_SEchild) );
        d = std::min( d, I(F_SWchild) );

        return d+1;
}


} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef Node
# endif // NODE_H

---