ClusterTreeNode.h

Go to the documentation of this file.

#ifndef GRT_CLUSTER_TREE_NODE_HEADER
#define GRT_CLUSTER_TREE_NODE_HEADER

#include "../../CoreAlgorithms/Tree/Node.h"

GRT_BEGIN_NAMESPACE
    
class ClusterTreeNode : public Node{
public:
    ClusterTreeNode(){
        nodeType = "ClusterTreeNode";
        parent = NULL;
        leftChild = NULL;
        rightChild = NULL;
        clear();
    }
    
    virtual ~ClusterTreeNode(){
        clear();
    }
    
    virtual bool predict_(VectorFloat &x) override{
        if( x[ featureIndex ] >= threshold ) return true;
        return false;
    }
    
    virtual bool predict_(VectorFloat &x,VectorFloat &y) override{
        
        if( isLeafNode ){
            if( y.size() != 1 ) y.resize( 1 );
            y[0] = clusterLabel;
            return true;
        }
        
        if( leftChild == NULL && rightChild == NULL )
            return false;
        
        if( predict_( x ) ){
            if( rightChild )
                return rightChild->predict_( x, y );
        }else{
            if( leftChild )
                return leftChild->predict_( x, y );
        }
        
        return false;
    }
    
    virtual bool clear() override{
        
        //Call the base class clear function
        Node::clear();
        
        nodeSize = 0;
        featureIndex = 0;
        threshold = 0;
        clusterLabel = 0;
        
        return true;
    }
    
    virtual bool print() const override{
        
        std::string tab = "";
        for(UINT i=0; i<depth; i++) tab += "\t";
        
        std::cout << tab << "depth: " << depth << " nodeSize: " << nodeSize << " featureIndex: " << featureIndex << " threshold " << threshold << " isLeafNode: " << isLeafNode << std::endl;
        std::cout << tab << "ClusterLabel: " << clusterLabel << std::endl;
        
        if( leftChild != NULL ){
            std::cout << tab << "LeftChild: " << std::endl;
            leftChild->print();
        }
        
        if( rightChild != NULL ){
            std::cout << tab << "RightChild: " << std::endl;
            rightChild->print();
        }
        
        return true;
    }
    
    virtual Node* deepCopy() const override{
        
        ClusterTreeNode *node = new ClusterTreeNode;
        
        if( node == NULL ){
            return NULL;
        }
        
        //Copy this node into the node
        node->depth = depth;
        node->isLeafNode = isLeafNode;
        node->nodeSize = nodeSize;
        node->featureIndex = featureIndex;
        node->threshold = threshold;
        node->clusterLabel = clusterLabel;
        
        //Recursively deep copy the left child
        if( leftChild ){
            node->leftChild = leftChild->deepCopy();
            node->leftChild->setParent( node );
        }
        
        //Recursively deep copy the right child
        if( rightChild ){
            node->rightChild = rightChild->deepCopy();
            node->rightChild->setParent( node );
        }
        
        return dynamic_cast<Node*>(node);
    }
    
    ClusterTreeNode* deepCopyTree() const{
        ClusterTreeNode *node = dynamic_cast<ClusterTreeNode*>(deepCopy());
        return node;
    }
    
    UINT getNodeSize() const{
        return nodeSize;
    }
    
    UINT getFeatureIndex() const{
        return featureIndex;
    }
    
    Float getThreshold() const{
        return threshold;
    }
    
    UINT getClusterLabel() const{
        return clusterLabel;
    }
    
    bool set(const UINT nodeSize,const UINT featureIndex,const Float threshold,const UINT clusterLabel){
        this->nodeSize = nodeSize;
        this->featureIndex = featureIndex;
        this->threshold = threshold;
        this->clusterLabel = clusterLabel;
        return true;
    }
    
protected:
    virtual bool saveParametersToFile(std::fstream &file) const override{
        
        if(!file.is_open())
        {
            errorLog << "saveParametersToFile(fstream &file) - File is not open!" << std::endl;
            return false;
        }
        
        //Save the custom ClusterTreeNode parameters
        file << "NodeSize: " << nodeSize << std::endl;
        file << "FeatureIndex: " << featureIndex << std::endl;
        file << "Threshold: " << threshold << std::endl;
        file << "ClusterLabel: " << clusterLabel << std::endl;
        
        return true;
    }
    
    virtual bool loadParametersFromFile(std::fstream &file) override{
        
        if(!file.is_open())
        {
            errorLog << "loadParametersFromFile(fstream &file) - File is not open!" << std::endl;
            return false;
        }
        
        std::string word;
        
        //Load the custom ClusterTreeNode Parameters
        file >> word;
        if( word != "NodeSize:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find NodeSize header!" << std::endl;
            return false;
        }
        file >> nodeSize;
        
        file >> word;
        if( word != "FeatureIndex:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find FeatureIndex header!" << std::endl;
            return false;
        }
        file >> featureIndex;
        
        file >> word;
        if( word != "Threshold:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find Threshold header!" << std::endl;
            return false;
        }
        file >> threshold;
        
        file >> word;
        if( word != "ClusterLabel:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find ClusterLabel header!" << std::endl;
            return false;
        }
        file >> clusterLabel;
        
        return true;
    }
    
    UINT clusterLabel;
    UINT nodeSize;
    UINT featureIndex;
    Float threshold;
    
    static RegisterNode< ClusterTreeNode > registerModule;
};

GRT_END_NAMESPACE

#endif //GRT_CLUSTER_TREE_NODE_HEADER