QmitknnUNetFolderParser.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef QmitknnUNetFolderParser_h
#define QmitknnUNetFolderParser_h
 
#include <QDirIterator>
#include <memory>
#include <functional>
#include <QString>
#include <vector>
 
struct FolderNode
{
  QString name;
  QString path; // parent
  std::vector<std::shared_ptr<FolderNode>> subFolders;
};
 
class QmitknnUNetFolderParser
{
public:
  QmitknnUNetFolderParser(const QString parentFolder);
  ~QmitknnUNetFolderParser() = default;
  QString getResultsFolder(); 
 
  template <typename T>
  T getModelNames()
  {
    auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
    return models;
  }
 
  template <typename T>
  T getTasksForModel(const QString &modelName)
  {
    std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
    auto tasks = GetSubFolderNamesFromNode<T>(modelNode);
    return tasks;
  }
 
  template <typename T>
  T getModelsForTask(const QString &taskName)
  {
    T modelsForTask;
    auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
    foreach (QString model, models)
    {
      QStringList taskList = getTasksForModel<QStringList>(model);
      if (taskList.contains(taskName, Qt::CaseInsensitive))
      {
        modelsForTask << model;
      }
    }
    return modelsForTask;
  }
 
  template <typename T>
  T getAllTasks()
  {
    T allTasks;
    auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
    foreach (QString model, models)
    {
      allTasks << getTasksForModel<QStringList>(model);
    }
    return allTasks;
  }
 
  template <typename T>
  T getTrainerPlannersForTask(const QString &taskName, const QString &modelName)
  {
    std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
    std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
    auto tps = GetSubFolderNamesFromNode<T>(taskNode);
    return tps;
  }
 
  template <typename T>
  T getFoldsForTrainerPlanner(const QString &trainer,
                              const QString &planner,
                              const QString &taskName,
                              const QString &modelName)
  {
    std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
    std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
    QString trainerPlanner = trainer + QString("__") + planner;
    std::shared_ptr<FolderNode> tpNode = GetSubNodeMatchingNameCrietria(trainerPlanner, taskNode);
    auto folds = GetSubFolderNamesFromNode<T>(tpNode);
    return folds;
  }
 
private:
  const int m_LEVEL = 4;
  std::shared_ptr<FolderNode> m_RootNode;
  
  std::function<bool(QString)> RuleEngine(int level);
 
  std::shared_ptr<FolderNode> GetSubNodeMatchingNameCrietria(const QString &queryName, std::shared_ptr<FolderNode> parentNode);
 
  template <typename T>
  T GetSubFolderNamesFromNode(const std::shared_ptr<FolderNode> parent)
  {
    T folders;
    std::vector<std::shared_ptr<FolderNode>> subNodes = parent->subFolders;
    for (std::shared_ptr<FolderNode> folder : subNodes)
    {
      folders.push_back(folder->name);
    }
    return folders;
  }
 
  void InitDirs(std::shared_ptr<FolderNode> parent, int level);
 
  void DeleteDirs(std::shared_ptr<FolderNode> parent, int level);
 
  template <typename T>
  T FetchFoldersFromDir(const QString &path, std::function<bool(QString)> callback)
  {
    T folders;
    for (QDirIterator it(path, QDir::AllDirs, QDirIterator::NoIteratorFlags); it.hasNext();)
    {
      it.next();
      if (!it.fileName().startsWith('.') && callback(it.filePath()))
      {
        folders.push_back(it.fileName());
      }
    }
    return folders;
  }
};
#endif