DataCollector.hpp

Go to the documentation of this file.

#ifndef SRC_UTILS_DATACOLLECTOR_HPP_
#define SRC_UTILS_DATACOLLECTOR_HPP_

#include <vector>
#include <string>
#include <map>
#include <limits>

#include <fstream>      // std::ofstream

#include<logger/Log.hpp>

#include <types/Color.hpp>
#include <types/MatrixTypes.hpp>

namespace mic {
namespace utils {

template <typename DATA_TYPE>
struct DataContainer {
    std::vector<DATA_TYPE> data;

    bool auto_scale;

    DATA_TYPE min_value;

    DATA_TYPE max_value;

    mic::types::color_rgba color;

    float line_width;
};

template<class DATA_TYPE>
using DataContainerPtr = typename std::shared_ptr < DataContainer < DATA_TYPE> >;

template<class LABEL_TYPE, class DATA_TYPE>
using DataContainers = typename std::map<LABEL_TYPE, DataContainerPtr <DATA_TYPE> >;



template<class LABEL_TYPE, class DATA_TYPE>
using DataContainerIt = typename std::map<LABEL_TYPE, DataContainerPtr <DATA_TYPE> >::iterator;


template <class LABEL_TYPE, class DATA_TYPE>
class DataCollector {
public:
    DataCollector() { };

    virtual ~DataCollector() { };

    void createContainer(LABEL_TYPE label_, DATA_TYPE min_, DATA_TYPE max_, mic::types::color_rgba color_ = mic::types::color_rgba(255, 255, 255, 180), float line_width_ = 1.0f) {
        LOG(LTRACE)<< "DataCollector::createDataContainer";

        DataContainerPtr<DATA_TYPE> tmp (new DataContainer<DATA_TYPE> );
        // Set min-max parameters.
        tmp->auto_scale = false;
        tmp->min_value = min_;
        tmp->max_value = max_;
        tmp->line_width = line_width_;
        tmp->color = color_;
        // Add container.
        containers.insert( std::make_pair (label_, tmp) );
    }

    void createContainer(LABEL_TYPE label_, mic::types::color_rgba color_ = mic::types::color_rgba(255, 255, 255, 180), float line_width_ = 1.0f) {
        LOG(LTRACE)<< "DataCollector::createDataContainer";

        DataContainerPtr<DATA_TYPE> tmp (new DataContainer<DATA_TYPE> );
        // Set min-max parameters.
        tmp->auto_scale = true;
        tmp->min_value = std::numeric_limits<DATA_TYPE>::max();
        tmp->max_value = std::numeric_limits<DATA_TYPE>::min();
        tmp->line_width = line_width_;
        tmp->color = color_;
        // Add data container.
        containers.insert( std::make_pair (label_, tmp) );
    }


    void addDataToContainer(LABEL_TYPE label_, DATA_TYPE value_){
        LOG(LTRACE)<< "DataCollector::addDataToContainer";

        // Try to find the label in registry.
        DataContainerIt<LABEL_TYPE, DATA_TYPE> it = containers.find(label_);

        if (it != containers.end()) {
            // Add new value to data.
            (it->second)->data.push_back(value_);
            // Check autoscale.
            if ((it->second)->auto_scale) {
                (it->second)->min_value = (value_ < (it->second)->min_value) ? value_ : (it->second)->min_value;
                (it->second)->max_value = (value_ > (it->second)->max_value) ? value_ : (it->second)->max_value;
            }
        } else {
            LOG(LERROR) << "There is no container with label: " << label_;
        }
    }

    DataContainerPtr<DATA_TYPE> getDataFromContainer(LABEL_TYPE label_){
        LOG(LTRACE)<< "DataCollector::getContainerData";

        // Try to find the label in registry.
        DataContainerIt<LABEL_TYPE, DATA_TYPE> it = containers.find(label_);

        if (it == containers.end()) {
            LOG(LERROR) << "There is no container with label: " << label_;
            // Return empty container.
            DataContainerPtr<DATA_TYPE> tmp (new DataContainer<DATA_TYPE> );
            tmp->auto_scale = true;
            tmp->min_value = std::numeric_limits<DATA_TYPE>::max();
            tmp->max_value = std::numeric_limits<DATA_TYPE>::min();
            return tmp;
        } else
            return it->second;
    }

    DataContainers< LABEL_TYPE, DATA_TYPE > getContainers(){
        LOG(LTRACE)<< "DataCollector::getContainer";
        return containers;
    }


    void exportDataToCsv(std::string filename_ = "data.csv"){
        LOG(LTRACE)<< "DataCollector::exportDataToCsv";
        // Open output filestream.
        std::ofstream output(filename_);

        // Iterate through containers.
        for(DataContainerIt<LABEL_TYPE, DATA_TYPE> it = containers.begin(); it != containers.end(); it++) {
            // Export header.
            output << it->first << ", min ,";
            output << (it->second)->min_value << ", max, ";
            output << (it->second)->max_value << std::endl;

            // Export data.
            if ((it->second)->data.size() > 1)
                std::copy((it->second)->data.begin(), (it->second)->data.end() - 1, std::ostream_iterator<DATA_TYPE>(output, ", "));
            if ((it->second)->data.size())
                output << (it->second)->data.back() << std::endl;
        }//: for
    }

    static void exportVectorToCsv(std::string filename_, std::string label_, std::vector<DATA_TYPE> data_, bool append_ = false){
        LOG(LTRACE)<< "DataCollector::exportVectorToCsv";
        // Open output filestream.
        std::ofstream output;
        if (!append_)
            output.open(filename_);
        else
            output.open(filename_, std::ofstream::out | std::ofstream::app);

        // Export header
        output << label_ << std::endl;

        // Export data.
        if (data_.size() > 1)
            std::copy(data_.begin(), data_.end() - 1, std::ostream_iterator<DATA_TYPE>(output, ", "));
        if (data_.size())
            output << data_.back() << std::endl;
    }

    static void exportValueToCsv(std::string filename_, std::string label_, DATA_TYPE value_, bool append_ = false){
        LOG(LTRACE)<< "DataCollector::exportValueToCsv";
        // Open output filestream.
        std::ofstream output;
        if (!append_)
            output.open(filename_);
        else
            output.open(filename_, std::ofstream::out | std::ofstream::app);

        // Export data.
        output << label_ << ", " << value_ << std::endl;
    }


    static void exportCommentToCsv(std::string filename_, std::string exportCommentToCsv, bool append_ = false){
        LOG(LTRACE)<< "DataCollector::exportCommentToCsv";
        // Open output filestream.
        std::ofstream output;
        if (!append_)
            output.open(filename_);
        else
            output.open(filename_, std::ofstream::out | std::ofstream::app);

        // Export data.
        output << exportCommentToCsv <<  std::endl;
    }


    static void exportMatrixToCsv(std::string filename_, std::string label_, std::shared_ptr< mic::types::Matrix<DATA_TYPE> > matrix_, bool append_ = false){
        LOG(LTRACE)<< "DataCollector::exportVectorToCsv";
        // Open output filestream.
        std::ofstream output;
        if (!append_)
            output.open(filename_);
        else
            output.open(filename_, std::ofstream::out | std::ofstream::app);

        // Export header.
        output << label_ << std::endl;

        // Export matrix.
        for (size_t y = 0; y < (size_t)matrix_->rows(); y++) {
            for (size_t x = 0; x < (size_t)matrix_->cols(); x++) {
                output << matrix_(y,x) << ", ";
            }//: for
        }//: for
        output << std::endl;
    }



    static void exportMatricesToCsv(std::string filename_, std::string label_, std::vector< mic::types::MatrixPtr<DATA_TYPE> > data_, bool append_ = false){
        LOG(LTRACE)<< "DataCollector::exportVectorToCsv";
        // Open output filestream.
        std::ofstream output;
        if (!append_)
            output.open(filename_);
        else
            output.open(filename_, std::ofstream::out | std::ofstream::app);

        // Export header.
        output << label_ << std::endl;

        for (size_t i=0; i<data_.size(); i++) {
            mic::types::MatrixPtr<DATA_TYPE> matrix_ptr = data_[i];

            //output << *matrix;

            //DATA_TYPE* data_ptr = matrix->data();
            // Export matrix.
            for (size_t y = 0; y < (size_t)matrix_ptr->rows(); y++) {
                for (size_t x = 0; x < (size_t)matrix_ptr->cols(); x++) {
                    output << (*matrix_ptr)(y,x) << ", ";
                }//: for
            }//: for
            //output << data_ptr[matrix->rows()*matrix->cols() -1] << std::endl;
            output << std::endl;
        }//: for
    }


protected:
    DataContainers< LABEL_TYPE, DATA_TYPE > containers;

};


template<class LABEL_TYPE, class DATA_TYPE>
using DataCollectorPtr = typename std::shared_ptr<mic::utils::DataCollector<LABEL_TYPE, DATA_TYPE > >;



} /* namespace utils */
} /* namespace mic */

#endif /* SRC_UTILS_DATACOLLECTOR_HPP_ */