support_eddl.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_SUPPORT_EDDL_H_
#define ECVL_SUPPORT_EDDL_H_

#include "ecvl/augmentations.h"
#include "ecvl/core/filesystem.h"
#include "ecvl/core/image.h"
#include "ecvl/dataset_parser.h"

#include <eddl/apis/eddl.h>

#include <mutex>

namespace ecvl
{
class DatasetAugmentations
{
    std::array<shared_ptr<Augmentation>, 3> augs_;
public:
    DatasetAugmentations(std::array<shared_ptr<Augmentation>, 3> augs = { nullptr,nullptr,nullptr })
        : augs_(augs)
    {}

// Getters: YAGNI

    bool Apply(SplitType st, Image& img, const Image& gt = Image())
    {
        if (augs_[+st]) { // Magic + operator
            augs_[+st]->Apply(img, gt);
            return true;
        }
        return false;
    }
};

class DLDataset : public Dataset
{
public:
    int batch_size_; 
    int n_channels_; 
    int n_channels_gt_; 
    SplitType current_split_; 
    std::vector<int> resize_dims_; 
    std::array<int, 3> current_batch_ = { 0,0,0 }; 
    ColorType ctype_; 
    ColorType ctype_gt_; 
    DatasetAugmentations augs_; 
    std::mutex  mutex_current_batch_; 
    DLDataset(const filesystem::path& filename,
        const int batch_size,
        DatasetAugmentations augs = DatasetAugmentations(),
        ColorType ctype = ColorType::BGR,
        ColorType ctype_gt = ColorType::GRAY,
        bool verify = false) :

        Dataset{ filename, verify },
        batch_size_{ batch_size },
        augs_(std::move(augs)),
        ctype_{ ctype },
        ctype_gt_{ ctype_gt }
    {
        current_split_ = SplitType::training;
        // if training is empty check test and validation and if one of them isn't empty, set it as current split
        if (GetSplit(SplitType::training).empty()) {
            if (!GetSplit(SplitType::test).empty()) {
                current_split_ = SplitType::test;
            }
            else if (!GetSplit(SplitType::validation).empty()) {
                current_split_ = SplitType::validation;
            }
        }

        Image tmp = this->samples_[0].LoadImage(ctype);
        // Initialize resize_dims_ after that augmentations on images are performed
        if (!augs_.Apply(SplitType::training, tmp)) {
            if (!augs_.Apply(SplitType::validation, tmp)) {
                augs_.Apply(SplitType::test, tmp);
            }
        }
        auto y = tmp.channels_.find('y');
        auto x = tmp.channels_.find('x');
        assert(y != std::string::npos && x != std::string::npos);
        resize_dims_.insert(resize_dims_.begin(), { tmp.dims_[y],tmp.dims_[x] });

        // Initialize n_channels_
        n_channels_ = tmp.Channels();

        // Initialize n_channels_gt_ if exists
        if (!GetSplit().empty()) {
            if (samples_[GetSplit()[0]].label_path_ != nullopt) {
                n_channels_gt_ = samples_[GetSplit()[0]].LoadImage(ctype_gt_, true).Channels();
            }
        }
    }

    std::vector<int>& GetSplit();

    std::vector<int>& GetSplit(const SplitType& split);

    void ResetCurrentBatch();

    void ResetAllBatches();

    void SetSplit(const SplitType& split);

    void LoadBatch(Tensor*& images, Tensor*& labels);

    void LoadBatch(Tensor*& images);
};

void TensorToImage(Tensor*& t, Image& img);

void TensorToView(Tensor*& t, View<DataType::float32>& v);

void ImageToTensor(const Image& img, Tensor*& t);

void ImageToTensor(const Image& img, Tensor*& t, const int& offset);

} // namespace ecvl

#endif // ECVL_SUPPORT_EDDL_H_