RegressionTreeNode.h

Go to the documentation of this file.

#ifndef GRT_REGRESSION_TREE_NODE_HEADER
#define GRT_REGRESSION_TREE_NODE_HEADER

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

GRT_BEGIN_NAMESPACE
    
class RegressionTreeNode : public Node{
public:
    RegressionTreeNode(){
        nodeType = "RegressionTreeNode";
        parent = NULL;
        leftChild = NULL;
        rightChild = NULL;
        clear();
    }
    
    virtual ~RegressionTreeNode(){
        clear();
    }
    
    virtual bool predict(const VectorFloat &x){
        if( x[ featureIndex ] >= threshold ) return true;
        return false;
    }
    
    virtual bool predict(const VectorFloat &x,VectorFloat &y){
        
        if( isLeafNode ){
            y = this->regressionData;
            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(){
        
        //Call the base class clear function
        Node::clear();
        
        nodeSize = 0;
        featureIndex = 0;
        threshold = 0;
        regressionData.clear();
        
        return true;
    }
    
    virtual bool print() const{
        
        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 << "RegressionData: ";
        for(UINT i=0; i<regressionData.size(); i++){
            std::cout << regressionData[i] << "\t";
        }
        std::cout << 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* deepCopyNode() const{
        
        RegressionTreeNode *node = new RegressionTreeNode;
        
        if( node == NULL ){
            return NULL;
        }
        
        //Copy this node into the node
        node->depth = this->depth;
        node->isLeafNode = this->isLeafNode;
        node->nodeSize = this->nodeSize;
        node->featureIndex = this->featureIndex;
        node->threshold = this->threshold;
        node->regressionData = this->regressionData;
        
        //Recursively deep copy the left child
        if( this->leftChild ){
            node->leftChild = this->leftChild->deepCopyNode();
            node->leftChild->setParent( node );
        }
        
        //Recursively deep copy the right child
        if( this->rightChild ){
            node->rightChild = this->rightChild->deepCopyNode();
            node->rightChild->setParent( node );
        }
        
        return dynamic_cast< Node* >( node );
    }
    
    RegressionTreeNode* deepCopyTree() const{
        RegressionTreeNode *node = dynamic_cast< RegressionTreeNode* >( deepCopyNode() );
        return node;
    }
    
    bool set(const UINT nodeSize,const UINT featureIndex,const Float threshold,const VectorFloat &regressionData){
        this->nodeSize = nodeSize;
        this->featureIndex = featureIndex;
        this->threshold = threshold;
        this->regressionData = regressionData;
        return true;
    }
    
protected:
    virtual bool saveParametersToFile( std::fstream &file ) const{
        
        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 << "RegressionDataSize: " << regressionData.getSize() << std::endl;
        file << "RegressionData: ";
        for(unsigned int i=0; i<regressionData.getSize(); i++){
            file << regressionData[i] << " ";
        }
        file << std::endl;
        
        return true;
    }
    
    virtual bool loadParametersFromFile( std::fstream &file ){
        
        if(!file.is_open())
        {
            errorLog << "loadFromFile(fstream &file) - File is not open!" << std::endl;
            return false;
        }
        
        std::string word;
        UINT regressionDataSize = 0;
        
        //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 != "RegressionDataSize:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find RegressionDataSize header!" << std::endl;
            return false;
        }
        file >> regressionDataSize;
        regressionData.resize(regressionDataSize);
        
        file >> word;
        if( word != "RegressionData:" ){
            errorLog << "loadParametersFromFile(fstream &file) - Failed to find RegressionData header!" << std::endl;
            return false;
        }
        for(unsigned int i=0; i<regressionData.getSize(); i++){
            file >> regressionData[i];
        }
        
        return true;
    }
    
    UINT nodeSize;
    UINT featureIndex;
    Float threshold;
    VectorFloat regressionData;
    
    static RegisterNode< RegressionTreeNode > registerModule;
};

GRT_END_NAMESPACE

#endif //GRT_REGRESSION_TREE_NODE_HEADER