algorithm_widget.cpp

Go to the documentation of this file.

//--------------------------------------------------
//---------------------------------------------------
#include "algorithm_widget.h"

#include "../controller/controller.h"
#include "config_widget.h"
#include "../algorithms/algorithm_config.h"

#include <QtGui/QGridLayout>
#include <QComboBox>
#include <QSpacerItem>
#include <QMessageBox>
#include <QPushButton>

#include <QListWidget>

namespace imedgine 
{
//--------------------------------------------------

AlgorithmWidget::AlgorithmWidget(
    algorithm_name_container_type list_of_algorithms,
    QWidget* parent, Qt::WFlags f)
  : QWidget(parent, f), config_widget_(0)
  {
  algorithm_name_container_type::const_iterator iterator =
    list_of_algorithms.begin();
  
    if(list_of_algorithms.size() == 0)
    {
      QMessageBox::critical(0, "Imedgine",
                            tr("Could not get the algorithms"));
      return;
    }
    setupUi();
    
    algorithm_selector_->addItem(QString(tr("-")));
      
    std::string old_key;
    while(iterator != list_of_algorithms.end())
    {
      std::string key = iterator->first;
      if (key != old_key)
      {
        //algorithm_selector_->addItem(QString(key.c_str()));
      }
      algorithm_selector_->addItem(QString((iterator->second).c_str()));
      old_key = key;
      ++iterator;
    }
    initializeConnections();
  }

//--------------------------------------------------
  
  AlgorithmWidget::~AlgorithmWidget()
  {
    
  }

//--------------------------------------------------
  
  void AlgorithmWidget::setupUi()
  {
    base_layout_ = new QGridLayout(this);
    algorithm_selector_ = new QComboBox();
    base_layout_->addWidget(algorithm_selector_, 0, 0, 1, 2);
    
    ok_button_ = new QPushButton(tr("OK", "AlgorithmWidget"));
    cancel_button_ = new QPushButton(tr("Cancel", "AlgorithmWidget"));
    base_layout_->addWidget(ok_button_, 3, 0, 1, 1);
    base_layout_->addWidget(cancel_button_, 3, 1, 1, 1);
    ok_button_->setEnabled(false);
    cancel_button_->setEnabled(false);
    
    configuration_layout_ = new QGridLayout();
    base_layout_->addLayout(configuration_layout_,1,0,2,2);
    
    QFrame* selector_frame_ = new QFrame();
    selector_frame_->setFrameShape(QFrame::StyledPanel);
    selector_frame_->setFrameShadow(QFrame::Raised);

    configuration_layout_->addWidget(selector_frame_,0,0);
    
    selector_layout_ = new QGridLayout(selector_frame_);
    
    QFrame* configuration_frame_ = new QFrame();
    configuration_frame_->setFrameShape(QFrame::StyledPanel);
    configuration_frame_->setFrameShadow(QFrame::Raised);
    
    configuration_layout_->addWidget(configuration_frame_, 1,0);
    
    configuration_widget_layout_ = new QGridLayout(configuration_frame_);
    
  }

  //--------------------------------------------------
  
  void AlgorithmWidget::initializeConnections()
  {
    connect(algorithm_selector_,SIGNAL(currentIndexChanged(const QString&)), 
            this, SLOT(algorithmChosen(const QString&)));

    connect(ok_button_,SIGNAL(pressed()), 
            this, SLOT(okPressed()));

  }

  //--------------------------------------------------
  
  void AlgorithmWidget::okPressed()
  {
    config_widget_->applyConfiguration();
    Controller::getInstance().runAlgorithm(
      algorithm_selector_->currentText().toStdString(),
      config_widget_->getConfiguration());
  }
  
  //--------------------------------------------------

  void AlgorithmWidget::datasetChanged(dataset_key_type const& dataset_name)
  {
    //FIXME it would be better if this wasn't necessary and adding a new
    //FIXME dataset would keep the selected old ones. Problem here is that
    //FIXME the addDatasetsToDropdown method always checks for possible
    //FIXME combinations using already_set_datasets_ and therefore everywhere
    //FIXME only displays slices if a slice was already set.
    already_set_datasets_.clear(); 
    for(std::vector<std::pair<QLabel*,QComboBox*> >::iterator iterator =
        label_with_drop_down_vector_.begin(); 
        iterator != label_with_drop_down_vector_.end(); ++iterator)
    {
      QLabel* temp_label = (*iterator).first;
      QComboBox* temp_combo_box = (*iterator).second;
      if (temp_combo_box->isEnabled())
      {
        addDatasetsToDropdown(temp_combo_box, temp_label->text().toStdString());
      }
    }
  }

//--------------------------------------------------
  
  void AlgorithmWidget::algorithmChosen(const QString& chosen_algorithm)
  {
    if(chosen_algorithm == "-")
    {
      removeConfigurationThings();
      return;
    }
    
    if(config_widget_ != 0)
    {
      removeConfigurationThings();
    }
    
    std::string algorithm = chosen_algorithm.toStdString();
    try
    {
      if (!Controller::getInstance().isAlgorithmLoaded(algorithm))
      {
        Controller::getInstance().loadAlgorithm(algorithm);
      }
    }
    catch (AlgorithmNotFoundException const&)
    {
      //TODO: notify application user or something
      return;
    }
    
    //config_widget_ = Controller::getInstance().createConfigWidget(algorithm);
    //configuration_widget_layout_->addWidget(config_widget_, 0, 0);
    //ok_button_->setEnabled(true);
    //cancel_button_->setEnabled(true);
    
    definition_ = Controller::getInstance().getAlgorithmDefinition(algorithm);
    
    AlgorithmDefinition::dataset_definition_collection_type input_datasets = definition_->getInputDatasets();
     
    unsigned int counter = 0; 
    for(AlgorithmDefinition::dataset_definition_collection_type::const_iterator iter=input_datasets.begin(); 
        iter!=input_datasets.end(); ++iter)
    {
      std::string name = iter->first;
      AlgorithmDefinition::dataset_definition_pointer_type dataset_definition = iter->second;

      //create datatset attributes. only attribute that can be set immediately is the in place attribute
      InputDatasetAttributes dataset_attributes;
      dataset_attributes.is_in_place = dataset_definition->isInPlace();
      input_dataset_attributes_.insert(std::make_pair(name, dataset_attributes));
      
      QLabel* temp_label = new QLabel(name.c_str());
      selector_layout_->addWidget(temp_label, counter, 0);
      QComboBox* temp_combo_box = new QComboBox();
      selector_layout_->addWidget(temp_combo_box, counter, 1);
      temp_combo_box->setEnabled(false);
      if (counter == 0) 
      {
        addDatasetsToDropdown(temp_combo_box, name);
      }

      connect(temp_combo_box, SIGNAL(currentIndexChanged(const QString&)), 
              this, SLOT(inputDatasetSelected(const QString&)));
      
      label_with_drop_down_vector_.push_back(std::make_pair(temp_label, temp_combo_box));
      ++counter;
    }
    
    label_with_drop_down_vector_[0].second->setEnabled(true);
  }


  void AlgorithmWidget::addDatasetsToDropdown(QComboBox* box, std::string name)
  {
    AlgorithmDefinition::accepted_datasets_type accepted_datasets =
      definition_->getPossibleCombinations(name, already_set_datasets_); 
    
    dataset_key_container_type dataset_keys;
    Controller::getInstance().getDatasetKeysOfTypes(accepted_datasets, dataset_keys);
    
    //handle 2d slices of 3d volumes
    for(AlgorithmDefinition::accepted_datasets_type::const_iterator accepted_ds_iter = accepted_datasets.begin();
        accepted_ds_iter!=accepted_datasets.end();
        ++accepted_ds_iter) 
    {
      dataset_key_container_type volume_dataset_keys;
      if (*accepted_ds_iter == ONE_BYTE_IMAGE_PIXEL_DATASET) 
      { 
        Controller::getInstance().getDatasetKeysOfType(ONE_BYTE_VOLUME_PIXEL_DATASET, volume_dataset_keys);
      }
      if (*accepted_ds_iter == TWO_BYTE_IMAGE_PIXEL_DATASET) 
      {  
        Controller::getInstance().getDatasetKeysOfType(TWO_BYTE_VOLUME_PIXEL_DATASET, volume_dataset_keys);
      }
      if (*accepted_ds_iter == FOUR_BYTE_IMAGE_PIXEL_DATASET) 
      {  
        Controller::getInstance().getDatasetKeysOfType(FOUR_BYTE_VOLUME_PIXEL_DATASET, volume_dataset_keys);
      }
      for(dataset_key_container_type::const_iterator volume_dataset_keys_iter=volume_dataset_keys.begin();
          volume_dataset_keys_iter != volume_dataset_keys.end();
          ++volume_dataset_keys_iter)
      {
        dataset_keys.push_back(*volume_dataset_keys_iter + ": Coronal");
        dataset_value_to_info_.insert(std::make_pair(*volume_dataset_keys_iter + ": Coronal", std::make_pair(*volume_dataset_keys_iter,CORONAL_SLICE_PART)));
        dataset_keys.push_back(*volume_dataset_keys_iter + ": Axial");
        dataset_value_to_info_.insert(std::make_pair(*volume_dataset_keys_iter + ": Axial", std::make_pair(*volume_dataset_keys_iter,AXIAL_SLICE_PART)));
        dataset_keys.push_back(*volume_dataset_keys_iter + ": Sagittal");
        dataset_value_to_info_.insert(std::make_pair(*volume_dataset_keys_iter + ": Sagittal", std::make_pair(*volume_dataset_keys_iter,SAGITTAL_SLICE_PART)));
      }
    }
    
    box->clear();
    box->addItem("-");
    for (dataset_key_container_type::const_iterator ds_iterator=dataset_keys.begin();
         ds_iterator != dataset_keys.end(); ++ds_iterator)
    {
      box->addItem((*ds_iterator).c_str());
    }
  }

//--------------------------------------------------
  
  void AlgorithmWidget::removeConfigurationThings()
  {
    already_set_datasets_.clear();
    for(std::vector<std::pair<QLabel*,QComboBox*> >::iterator iterator =
        label_with_drop_down_vector_.begin(); 
        iterator != label_with_drop_down_vector_.end(); ++iterator)
    {
      QLabel* temp_label = (*iterator).first;
      QComboBox* temp_combo_box = (*iterator).second;
      
      selector_layout_->removeWidget(temp_label);
      selector_layout_->removeWidget(temp_combo_box);
      
      delete temp_label;
      delete temp_combo_box;
    }
    
    label_with_drop_down_vector_.clear();
    
    configuration_widget_layout_->removeWidget(config_widget_);
    delete config_widget_;
    config_widget_ = 0;
  }

//--------------------------------------------------

  void AlgorithmWidget::setSliceTypeForVolumeType(dataset_type& type)
  {
    if (type == ONE_BYTE_VOLUME_PIXEL_DATASET)
    {
      type = ONE_BYTE_IMAGE_PIXEL_DATASET;
    }
    else if (type == TWO_BYTE_VOLUME_PIXEL_DATASET)
    {
      type = TWO_BYTE_IMAGE_PIXEL_DATASET;
    }
    else if (type == FOUR_BYTE_VOLUME_PIXEL_DATASET)
    {
      type = FOUR_BYTE_IMAGE_PIXEL_DATASET;
    }
  }

//--------------------------------------------------
  
  void AlgorithmWidget::inputDatasetSelected(const QString& selected_dataset)
  {
    unsigned int input_dataset_position = 0;
    bool dataset_found = false;
   
    std::string selected_ds = selected_dataset.toStdString();
    if (selected_ds != "-" && selected_ds != "")
    {
      dropdown_value_to_dataset_info_map_type::const_iterator ds_value_to_info_iter = dataset_value_to_info_.find(selected_ds);
      
      dataset_part_type dataset_part = WHOLE_DATASET_PART;
      std::string ds_name = selected_ds;
      if (ds_value_to_info_iter != dataset_value_to_info_.end())
      {
        ds_name = ds_value_to_info_iter->second.first;
        dataset_part = ds_value_to_info_iter->second.second; 
      }
      
      std::string name;
      for (unsigned int counter = 0; counter < label_with_drop_down_vector_.size(); 
            ++counter)
      {
        if(sender() == label_with_drop_down_vector_[counter].second)
        {
          QLabel *label = label_with_drop_down_vector_[counter].first;
          name = label->text().toStdString();
          dataset_pointer_type dataset = Controller::getInstance().getDataset(ds_name);
          dataset_type ds_type = dataset->getDatasetType();
          if (dataset_part != WHOLE_DATASET_PART)
          {
            setSliceTypeForVolumeType(ds_type);
          }
          
          already_set_datasets_.erase(name);
          already_set_datasets_.insert(std::make_pair(name, ds_type));
          
          InputDatasetAttributes attributes = input_dataset_attributes_[label->text().toStdString()];
          attributes.dataset_part = dataset_part;
          attributes.dataset_key = ds_name;
          input_dataset_attributes_[label->text().toStdString()] = attributes;
          
          input_dataset_position = counter + 1;
          dataset_found = true;
          break;
        }
      }

      if (dataset_found && input_dataset_position != label_with_drop_down_vector_.size())
      {
        label_with_drop_down_vector_[input_dataset_position].second->setEnabled(true);
        addDatasetsToDropdown(label_with_drop_down_vector_[input_dataset_position].second,
           label_with_drop_down_vector_[input_dataset_position].first->text().toStdString());
      }

      //last one selected
      if (input_dataset_position == label_with_drop_down_vector_.size())
      {
        if (config_widget_ != 0)
        {
          configuration_widget_layout_->removeWidget(config_widget_);
          delete config_widget_;
          config_widget_ = 0;
        }
        config_widget_ = Controller::getInstance().createConfigWidget(algorithm_selector_->currentText().toStdString());
        configuration_widget_layout_->addWidget(config_widget_, 0, 0);
        ok_button_->setEnabled(true);
        cancel_button_->setEnabled(true);

        config_dataset_id_to_input_map_type input_ds_map;
        for (std::vector<std::pair<QLabel*,QComboBox*> >::const_iterator ds_iterator =
             label_with_drop_down_vector_.begin();
             ds_iterator != label_with_drop_down_vector_.end();++ds_iterator)
        {
          QLabel *label = ds_iterator->first;
          dataset_name_to_attributes_map_type::const_iterator name_to_attributes_iter =
              input_dataset_attributes_.find(label->text().toStdString());
          if (name_to_attributes_iter != input_dataset_attributes_.end())
          {
            InputDatasetAttributes attributes = name_to_attributes_iter->second;
            input_ds_map.insert(std::make_pair(label->text().toStdString(), attributes));
          }
          else
          {
            //TODO throw exception
          } 
        }
        
        if (config_widget_ != 0)
        {
          // set the metadata for the whole input datasets within the configuration
          config_dataset_id_to_input_map_type::const_iterator input_ds_iter = 
              input_ds_map.begin();
          for ( ; input_ds_iter != input_ds_map.end(); ++input_ds_iter)
          {
            if (input_ds_iter->second.dataset_part == WHOLE_DATASET_PART)
            {
              try
              {
                config_widget_->setMetadataForInputDataset(input_ds_iter->first, 
                  Controller::getInstance().getMetadataFor(
                    input_ds_iter->second.dataset_key));
              }
              catch (DatasetNotFoundException const&)
              {
                continue;
              }
            }
          }
        }
        
        std::map<config_dataset_id_type, std::pair<dataset_key_type, dataset_type> > 
            new_dataset_keys_and_types_map;
        
        Controller::getInstance().setInputDatasetsInConfiguration(
            config_widget_->getConfiguration(), input_ds_map, new_dataset_keys_and_types_map);
        
        
        if (config_widget_ != 0)
        {
          std::map<config_dataset_id_type, std::pair<dataset_key_type, dataset_type> >::const_iterator 
              new_keys_and_types_iter = new_dataset_keys_and_types_map.begin();
          for ( ; new_keys_and_types_iter != new_dataset_keys_and_types_map.end();
                  ++new_keys_and_types_iter)
          {
            try
            {
              config_widget_->setMetadataForInputDataset(
                  new_keys_and_types_iter->first, 
                    Controller::getInstance().getMetadataFor(
                        new_keys_and_types_iter->second.first));
            }
            catch (DatasetNotFoundException const&)
            {
              continue;
            }
          }
        
          // Show the configuration widget
          if (!config_widget_->showConfiguration())
          {
           //TODO handle error in configuration widget
           return;
          }
        }
                
        config_dataset_id_to_output_map_type ds_id_to_output_map;
        definition_->setOutputDatasetIds(ds_id_to_output_map);

        Controller::getInstance().setOutputDatasetsInConfiguration(
            config_widget_->getConfiguration(), ds_id_to_output_map, new_dataset_keys_and_types_map);
        
        if (new_dataset_keys_and_types_map.empty() == false)
        {
          std::vector<std::pair<dataset_key_type, dataset_type> > new_keys_and_types_array;
          
          std::map<config_dataset_id_type, std::pair<dataset_key_type, dataset_type> >::const_iterator 
              new_keys_and_types_iter = new_dataset_keys_and_types_map.begin();
          
          for ( ; new_keys_and_types_iter != new_dataset_keys_and_types_map.end();
                  ++new_keys_and_types_iter)
          {
            new_keys_and_types_array.push_back(new_keys_and_types_iter->second);
          }
          emit notifyNewDatasetGeneration(new_keys_and_types_array);
        }
      }
    }
  }
}

---