dataset_parser.h

Go to the documentation of this file.

/*
* ECVL - European Computer Vision Library
* Version: 0.3.4
* copyright (c) 2021, Università degli Studi di Modena e Reggio Emilia (UNIMORE), AImageLab
* Authors:
*    Costantino Grana (costantino.grana@unimore.it)
*    Federico Bolelli (federico.bolelli@unimore.it)
*    Michele Cancilla (michele.cancilla@unimore.it)
*    Laura Canalini (laura.canalini@unimore.it)
*    Stefano Allegretti (stefano.allegretti@unimore.it)
* All rights reserved.
*/

#ifndef ECVL_DATASET_PARSER_H_
#define ECVL_DATASET_PARSER_H_

#include "ecvl/core.h"
#include "ecvl/core/filesystem.h"
#include "ecvl/core/optional.h"

#include <iostream>
#include <map>
#include <vector>
#include <regex>

#include "yaml-cpp/yaml.h"

// This allows to define strongly typed enums and convert them to int with just a + in front
#define UNSIGNED_ENUM_CLASS(name, ...) enum class name : unsigned { __VA_ARGS__ };\
inline constexpr unsigned operator+ (name const val) { return static_cast<unsigned>(val); }

namespace ecvl
{
UNSIGNED_ENUM_CLASS(SplitType, training, validation, test)
class Sample
{
public:
    std::vector<filesystem::path> location_; 
    optional<std::vector<int>> label_; 
    optional<filesystem::path> label_path_; 
    optional<std::map<int, std::string>> values_; 
    std::vector<int> size_; 
    ecvl::Image LoadImage(ecvl::ColorType ctype = ecvl::ColorType::BGR, const bool& is_gt = false);
};

class Split
{
public:
    std::vector<int> training_;   
    std::vector<int> validation_; 
    std::vector<int> test_;       
};

class Dataset
{
public:
    std::string name_ = "DeepHealth dataset"; 
    std::string description_ = "This is the DeepHealth example dataset!"; 
    std::vector<std::string> classes_; 
    std::vector<std::string> features_; 
    std::vector<Sample> samples_; 
    Split split_; 
    Dataset() {}

    Dataset(const filesystem::path& filename, bool verify = false);

    void Dump(const filesystem::path& file_path);

    // RegEx which matchs URLs
    static const std::regex url_regex_;

private:
    std::map<std::string, int> features_map_;
    void DecodeImages(const YAML::Node& node, const filesystem::path& root_path, bool verify);
    void FindLabel(Sample& sample, const YAML::Node& n);
};
} // namespace ecvl

namespace YAML
{
template<>
struct convert<ecvl::Split>
{
    /*static Node encode(const ecvl::Split& rhs)
    {
        Node node;
        node.push_back(rhs.x);
        return node;
    }*/

    static bool decode(const YAML::Node& node, ecvl::Split& rhs)
    {
        if (node["training"].IsDefined()) {
            rhs.training_ = node["training"].as<std::vector<int>>();
        }
        if (node["validation"].IsDefined()) {
            rhs.validation_ = node["validation"].as<std::vector<int>>();
        }
        if (node["test"].IsDefined()) {
            rhs.test_ = node["test"].as<std::vector<int>>();
        }
        return true;
    }
};
} // namespace YAML
#endif // ECVL_DATASET_PARSER_H_