controller.cpp

Go to the documentation of this file.

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


#include "controller.h"
#include "config_parser.h"
#include "config_handler.h"
#include "../global/global_definitions.h"
#include "../global/settings.h"
#include "../datasets/dataset_definitions.h"
#include "../gui/config_widget.h"

#include "../datasets/one_byte_image_pixel_dataset.h"
#include "../datasets/two_byte_image_pixel_dataset.h"
#include "../datasets/four_byte_image_pixel_dataset.h"
#include "../datasets/one_byte_volume_pixel_dataset.h"
#include "../datasets/two_byte_volume_pixel_dataset.h"
#include "../datasets/four_byte_volume_pixel_dataset.h"


#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <QtXml/QXmlDefaultHandler>
#include <iostream>

namespace imedgine 
{
  //---------------------------------------------------
  
  Controller::Controller()
  : algorithm_config_(new AlgorithmConfig()),
    gui_interaction_mode_(STANDARD_MODE)
  {
  }

  //---------------------------------------------------
  
  Controller::~Controller()
  {
#ifdef DEBUG
    std::cout << "Deleting Controller" << std::endl;
#endif
  }
  
  //---------------------------------------------------
  
  Controller& Controller::getInstance()
  {
    static Controller instance;
    return instance;
  }
  
  //---------------------------------------------------
  
  std::pair<dataset_key_type, dataset_type> 
      Controller::loadDataset(std::string filename)
      throw(FormatNotSupportedException, NullPointerException)
  {
    std::string extension = extractExtension(filename);

    // throws FormatNotSupportedException
    DataIOFactory::data_io_type data_io = 
      data_io_factory_.createDataIO(extension);

    std::string dataset_key = generateDatasetKeyFromFilename(filename);
       
    std::pair<dataset_pointer_type, dataset_type> dataset_pointer_and_type(
        data_io->loadDataset(filename, dataset_key));  
    
    if (dataset_pointer_and_type.first.get() == 0)
    {
      throw(NullPointerException("Controller::loadDataset"));
    }   
    
    dataset_pointer_map_.insert(
        std::make_pair(dataset_key, dataset_pointer_and_type.first));
    
    dataset_filename_map_.insert(
        std::make_pair(dataset_key, filename));

    return(std::make_pair(dataset_key, dataset_pointer_and_type.second));
  }
  
  //---------------------------------------------------
  
  void Controller::writeDataset(dataset_key_type dataset_key, std::string filename)
      throw(DatasetNotFoundException, FormatNotSupportedException)
  {
    dataset_pointer_map_const_iterator_type dataset_iter = 
        dataset_pointer_map_.find(dataset_key);
    if (dataset_iter == dataset_pointer_map_.end())
    {
      DatasetNotFoundException exc(dataset_key); 
      throw(exc);
    } 
    
    std::string extension = extractExtension(filename);
    // throws FormatNotSupportedException
    DataIOFactory::data_io_type data_io = 
        data_io_factory_.createDataIO(extension);
    
    data_io->writeDataset(dataset_iter->second, filename);
  }
  
  //---------------------------------------------------
  
  bool Controller::removeDataset(dataset_key_type dataset_key)
  {
    data_view_mediator_.removeDataset(dataset_key);
    dataset_filename_map_.erase(dataset_key);
    return(dataset_pointer_map_.erase(dataset_key) == 1);
  }
  
  std::string const& Controller::getDatasetFilename(dataset_key_type dataset_key)
      throw(DatasetNotFoundException)
  {
    dataset_filename_map_const_iterator_type filename_iter = 
        dataset_filename_map_.find(dataset_key);
    if (filename_iter == dataset_filename_map_.end())
    {
      DatasetNotFoundException exc(dataset_key); 
      throw(exc);
    } 
    return(filename_iter->second);
  }
  
  //---------------------------------------------------
  
  void Controller::getLoadedDatasetKeys(std::vector<dataset_key_type>& key_container) const
  {
    for (dataset_pointer_map_const_iterator_type dataset_iter = 
         dataset_pointer_map_.begin();
         dataset_iter != dataset_pointer_map_.end(); ++dataset_iter)
    {
      key_container.push_back(dataset_iter->first);
    }
  }
  
  //---------------------------------------------------
  
  dataset_pointer_type Controller::getDataset(Controller::dataset_key_type dataset_key) const
      throw(DatasetNotFoundException)
  {
    dataset_pointer_map_const_iterator_type dataset_iter = 
      dataset_pointer_map_.find(dataset_key);
    if (dataset_iter == dataset_pointer_map_.end())
    {
      DatasetNotFoundException exc(dataset_key); 
      throw(exc);
    }
    return(dataset_iter->second);
  }
  
  //--------------------------------------------------- 
  
  metadata_pointer_type Controller::getMetadataFor(dataset_key_type dataset_key) const
      throw(DatasetNotFoundException, NullPointerException)
  {
    dataset_pointer_map_const_iterator_type dataset_iter = 
        dataset_pointer_map_.find(dataset_key);
    if (dataset_iter == dataset_pointer_map_.end())
    {
      DatasetNotFoundException exc(dataset_key); 
      throw(exc);
    }
    if (dataset_iter->second.get() == 0)
    {
      throw(NullPointerException("Controller::getMetadataFor"));
    }
    return(dataset_iter->second->getMetadata());
  }
    
  
  //--------------------------------------------------- 
  
  void Controller::getDatasetKeysOfType(dataset_type type, 
                            dataset_key_container_type& dataset_key_container)
      throw(NullPointerException)
  {
    for (dataset_pointer_map_const_iterator_type dataset_iter = 
          dataset_pointer_map_.begin(); 
         dataset_iter != dataset_pointer_map_.end(); ++dataset_iter)
    {
      if (dataset_iter->second.get() == NULL)
      {
        throw(NullPointerException("Controller::getDatasetKeysOfType"));
      }
      if (dataset_iter->second->getDatasetType() == type)
      {
        dataset_key_container.push_back(dataset_iter->first);
      }
    }
  }
 
  //--------------------------------------------------- 
  
  void Controller::getDatasetKeysOfTypes(AlgorithmDefinition::accepted_datasets_type types, 
                            dataset_key_container_type& dataset_key_container)
      throw(NullPointerException)
  {
    for (AlgorithmDefinition::accepted_datasets_type::const_iterator types_iter = 
          types.begin();types_iter != types.end();++types_iter)
    {
      getDatasetKeysOfType(*types_iter, dataset_key_container);
    }
  }

  
 //--------------------------------------------------- 
  
  view_pointer_type Controller::getViewOfDataset(
      view_type type, dataset_key_type dataset_key)
      throw(DatasetNotFoundException)
   {
     dataset_pointer_map_iterator_type dataset_iter = 
         dataset_pointer_map_.find(dataset_key);
     if (dataset_iter == dataset_pointer_map_.end())
     {
       DatasetNotFoundException exc(dataset_key); 
       throw(exc);
     }
        
     return(data_view_mediator_.getViewOfDataset(dataset_iter->second, type));
   }  
   
   //---------------------------------------------------
   
   void Controller::getDependentViewIDsOfDataset(
       dataset_key_type dataset_key, view_id_container_type& target_container) const
       throw(DatasetNotFoundException, NullPointerException)
   {
     dataset_pointer_map_const_iterator_type dataset_iter = 
         dataset_pointer_map_.find(dataset_key);
     if (dataset_iter == dataset_pointer_map_.end())
     {
       DatasetNotFoundException exc(dataset_key); 
       throw(exc);
     }
     data_view_mediator_.getDependentViewIDsOfDataset(
         dataset_key, target_container);
   }
    
   //---------------------------------------------------
   
   view_type Controller::getViewTypeForDatasetSlice(
       dataset_key_type dataset_key, slice_type slice)
       throw(DatasetNotFoundException)
   {
     dataset_pointer_map_iterator_type dataset_iter = 
         dataset_pointer_map_.find(dataset_key);
     if (dataset_iter == dataset_pointer_map_.end())
     {
       DatasetNotFoundException exc(dataset_key); 
       throw(exc);
     }
     
     switch (slice)
     {
       case AXIAL_SLICE :
       {
         return(XY_SLICE_VIEW);
       }
       case CORONAL_SLICE :
       {
         return(YZ_SLICE_VIEW);
       }
       case SAGITTAL_SLICE :
       {
         return(XZ_SLICE_VIEW);
       }
       default :
       {
         return(UNDEF_VIEW);
       }
     }
   }
   
   //---------------------------------------------------
   
   slice_type Controller::getDatasetSliceForViewType(
       dataset_key_type dataset_key, view_type type)
       throw(DatasetNotFoundException)
   {
     dataset_pointer_map_iterator_type dataset_iter = 
         dataset_pointer_map_.find(dataset_key);
     if (dataset_iter == dataset_pointer_map_.end())
     {
       DatasetNotFoundException exc(dataset_key); 
       throw(exc);
     }
     
     switch (type)
     {
       case XY_SLICE_VIEW :
       {
         return(AXIAL_SLICE);
       }
       case YZ_SLICE_VIEW :
       {
         return(CORONAL_SLICE);
       }
       case XZ_SLICE_VIEW :
       {
         return(SAGITTAL_SLICE);
       }
       default :
       {
         return(UNDEF_SLICE);
       }
     }
   }
   
  //---------------------------------------------------
    
  void Controller::deleteViews(view_id_container_type view_ids)
      throw(NullPointerException)
  {
    for (view_id_container_type::const_iterator view_id_iter = view_ids.begin();
         view_id_iter != view_ids.end(); ++view_id_iter)
    {
      // throws NullPointerException
      data_view_mediator_.deleteView(*view_id_iter);   
    }            
  }         

  void Controller::loadConfiguration(std::string config_file_name)
  {
#ifdef DEBUG
    std::cout << "loading configuration" << std::endl;
#endif
    boost::shared_ptr<ConfigHandler> config_handler(new ConfigHandler(
          AlgorithmConfig::algorithm_config_pointer_type(algorithm_config_)));
    ConfigParser::parseConfiguration(config_file_name, config_handler);
    algorithm_config_->setAlgorithmLibraryPath(
      (Settings::getInstance())->getStringValue("algorithms_path", "/"));
  }

  //---------------------------------------------------
  
  algorithm_name_container_type Controller::getLoadedAlgorithmNames() const
  {
    return algorithm_config_->getLoadedAlgorithmNames();
  }

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

  std::string Controller::extractExtension(std::string filename) const
  {
    if (filename.empty())
    {
      //TODO exception?
      return "";
    }
    std::string::size_type point_pos = filename.rfind(".");
    if (point_pos == std::string::npos)
    {
      //TODO exception?
      return "";
    }
    return filename.substr(point_pos+1, filename.size() - point_pos + 1);
  }

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

  std::string Controller::generateDatasetKeyFromFilename(std::string filename) const
  {
    if (filename.empty())
    {
      //TODO exception?
      return "";
    }

    std::string dataset_key;
    std::string::size_type slash_pos = 
        filename.rfind(DIRECTORY_SEPARATOR);
    std::string::size_type file_name_start = slash_pos + 1;

    if (slash_pos == std::string::npos)
    {
      file_name_start = 0;
    }

    std::string::size_type point_pos = filename.rfind(".");

    if (point_pos == std::string::npos)
    {
      dataset_key = filename.substr(file_name_start, filename.length() - file_name_start); 
    }
    else
    {
      dataset_key = filename.substr(file_name_start, point_pos - file_name_start);
    }

    makeDatasetKeyUnique(dataset_key);
    
    return(dataset_key);

  } 
  
  //---------------------------------------------------
  
  void Controller::makeDatasetKeyUnique(dataset_key_type& dataset_key) const
  {
    unsigned short dataset_number = 0;
    std::string original_key = dataset_key;
    dataset_pointer_map_const_iterator_type dataset_iter;

    if ((dataset_iter = dataset_pointer_map_.find(dataset_key)) != 
         dataset_pointer_map_.end())
    {
      dataset_key.append(std::string(" ") + boost::lexical_cast<std::string>(++dataset_number));
    }

    while ((dataset_iter = dataset_pointer_map_.find(dataset_key)) != 
            dataset_pointer_map_.end())
    {
      dataset_key = original_key;
      dataset_key.append(boost::lexical_cast<std::string>(++dataset_number));
    }
  }
  
  //---------------------------------------------------
  
  AlgorithmConfig::algorithm_definition_pointer_type Controller::getAlgorithmDefinition(std::string name) const
    throw(AlgorithmNotFoundException)
  {
    return algorithm_config_->getAlgorithmDefinition(name);
  }

  //---------------------------------------------------
  
  bool Controller::isAlgorithmLoaded(std::string name)
  {
    return algorithm_factory_.isAlgorithmLoaded(name);
  }
  
  //---------------------------------------------------
  
  void Controller::loadAlgorithm(std::string name)
    throw(AlgorithmNotFoundException)
  {
    std::string full_path(algorithm_config_->getAlgorithmLibraryPath());
    std::string library_name = algorithm_config_->getAlgorithmDefinition(name)->getLibraryName();
    full_path.append(library_name);
    algorithm_factory_.loadAlgorithm(name, full_path);
  }
  
  //---------------------------------------------------
  
  void Controller::runAlgorithm(std::string key,
      configuration_pointer_type algorithm_config)
    throw(AlgorithmNotFoundException, NullPointerException)
  {
    AlgorithmFactory::algorithm_pointer_type algorithm =
        algorithm_factory_.createAlgorithm(key);
    
    if (algorithm.get() == 0)
    {
      throw(NullPointerException("Controller::runAlgorithm"));
    }
    
    algorithm->setConfiguration(algorithm_config);
     
    connect(algorithm.get(), SIGNAL(datasetChangedSignal(dataset_key_type const&)),
            this, SLOT(datasetChangedSlot(dataset_key_type const&)));
    
    algorithm->run();
  }
  
  //---------------------------------------------------

  config_widget_pointer_type Controller::createConfigWidget(
    std::string key) const
      throw(AlgorithmNotFoundException, NullPointerException)
  {
    config_widget_pointer_type config_widget = algorithm_factory_.createConfigWidget(key);
    configuration_pointer_type configuration = algorithm_factory_.createConfiguration(key);
    config_widget->setConfiguration(configuration);
    return config_widget;
  }

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

  metadata_pointer_type Controller::getMetadataForDataset(std::string dataset_key) const
    throw(DatasetNotFoundException, NullPointerException)
  {
    dataset_pointer_map_type::const_iterator ds_iterator = dataset_pointer_map_.find(dataset_key);
    if (ds_iterator == dataset_pointer_map_.end())
    {
      DatasetNotFoundException exc(dataset_key); 
      throw(exc);
    }
    else
    {
      if (ds_iterator->second.get() == 0) 
      {
        throw(NullPointerException("getMetadataForDatasets"));
      }
      return ds_iterator->second->getMetadata();
    }

  }


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

  void Controller::setGuiInteractionMode(gui_interaction_mode_type gui_interaction_mode)
  {
    gui_interaction_mode_ = gui_interaction_mode;
  }

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

  gui_interaction_mode_type Controller::getGuiInteractionMode()
  {
    return gui_interaction_mode_;
  }
  
  //--------------------------------------------------
  
  void Controller::setInputDatasetsInConfiguration(configuration_pointer_type configuration, 
    config_dataset_id_to_input_map_type input_datasets,
    std::map<config_dataset_id_type, std::pair<dataset_key_type, dataset_type> >& new_dataset_keys_and_types)
      throw(NullPointerException, DatasetNotFoundException, InvalidCastException)
  {
    if (configuration.get() == 0)
    {
      throw(NullPointerException("Controller::setInputDatasetsInConfiguration"));
    }
    
    for (config_dataset_id_to_input_map_type::const_iterator input_datasets_iter = 
         input_datasets.begin(); 
         input_datasets_iter != input_datasets.end(); 
         ++input_datasets_iter)
    {
      dataset_key_type dataset_key(input_datasets_iter->second.dataset_key);
      dataset_pointer_map_const_iterator_type dataset_iter = 
          dataset_pointer_map_.find(dataset_key);
      if (dataset_iter == dataset_pointer_map_.end())
      {
        DatasetNotFoundException exc(dataset_key); 
        throw(exc);
      }
      
      dataset_pointer_type source_dataset(dataset_iter->second);
      
      if (source_dataset.get() == 0)
      {
        throw(NullPointerException("Controller::setInputDatasetsInConfiguration"));
      }
      
      switch (input_datasets_iter->second.dataset_part)
      {
        case WHOLE_DATASET_PART :
        {
          configuration->registerDataset(
              input_datasets_iter->first, source_dataset);
          break;
        }
        case AXIAL_SLICE_PART :
        case CORONAL_SLICE_PART :
        case SAGITTAL_SLICE_PART :
        {
          volume_pixel_dataset_pointer_type volume_dataset(
              source_dataset, boost::detail::dynamic_cast_tag());
          
          if (volume_dataset.get() == 0)
          {
            throw(InvalidCastException("Controller::setInputDatasetsInConfiguration",
                  "dataset_pointer_type", "volume_pixel_dataset_pointer_type"));
          }

          // derive the dataset type of the extracted image from the 
          // type of the source volume
          dataset_type type = UNDEF_DATASET;
          switch (volume_dataset->getDatasetType())
          {
            case ONE_BYTE_VOLUME_PIXEL_DATASET :
            {
              type = ONE_BYTE_IMAGE_PIXEL_DATASET;
              break;
            }
            case TWO_BYTE_VOLUME_PIXEL_DATASET :
            {
              type = TWO_BYTE_IMAGE_PIXEL_DATASET;
              break;
            }
            case FOUR_BYTE_VOLUME_PIXEL_DATASET :
            {
              type = FOUR_BYTE_IMAGE_PIXEL_DATASET;
              break;
            }
            default :
            {
              continue;
            }
          }
          
          dataset_key_type image_key(input_datasets_iter->first);
          makeDatasetKeyUnique(image_key);
          
          slice_type slice = this->datasetPartToSliceType(
              input_datasets_iter->second.dataset_part);
          
          dataset_pointer_type image;
          
          // extract the image from the volume
          switch (this->getViewTypeForDatasetSlice(volume_dataset->getDatasetKey(), slice))
          {
            case XY_SLICE_VIEW :
            {
              image = volume_dataset->getImageXY(
                  volume_dataset->getFocusPoint()[Z_DIMENSION], image_key);
              configuration->registerDataset(input_datasets_iter->first, image);
              break;
            }
            case XZ_SLICE_VIEW :
            {
              image = volume_dataset->getImageXZ(
                  volume_dataset->getFocusPoint()[Y_DIMENSION], image_key);
              configuration->registerDataset(input_datasets_iter->first, image);
              break;
            }
            case YZ_SLICE_VIEW :
            {
              image = volume_dataset->getImageYZ(
                  volume_dataset->getFocusPoint()[X_DIMENSION], image_key);
              configuration->registerDataset(input_datasets_iter->first, image);
              break;
            }
            default :
            {
              return;
            }
          }
          
          if (input_datasets_iter->second.is_in_place == true)
          {
            image->setDirty(true);
            
            dataset_pointer_map_.insert(
              std::make_pair(image_key, image));
            dataset_filename_map_.insert(
                std::make_pair(image_key, std::string()));
            
            std::cout << "Adding new key: " << input_datasets_iter->first << ", " << dataset_key << std::endl;
            
            new_dataset_keys_and_types.insert(
                std::make_pair(input_datasets_iter->first,
                               std::make_pair(image_key, type)));
          }
          
          break;
        }
      }
    }
  }
  
  //--------------------------------------------------
  
  void Controller::setOutputDatasetsInConfiguration(configuration_pointer_type configuration,
    config_dataset_id_to_output_map_type output_datasets,
    std::map<config_dataset_id_type, std::pair<dataset_key_type, dataset_type> >& new_dataset_keys_and_types)
      throw(NullPointerException)
  {
    if (configuration.get() == 0)
    {
      throw(NullPointerException("Controller::setInputDatasetsInConfiguration"));
    }
    
    dataset_key_type dataset_key;
    dataset_pointer_type dataset;
    
    for (config_dataset_id_to_output_map_type::const_iterator output_datasets_iter = 
         output_datasets.begin(); 
         output_datasets_iter != output_datasets.end(); 
         ++output_datasets_iter)
    {
      dataset_key = output_datasets_iter->first;
      makeDatasetKeyUnique(dataset_key);
      
      switch (output_datasets_iter->second)
      {
        case ONE_BYTE_IMAGE_PIXEL_DATASET :
        {
          dataset.reset(
              new OneByteImagePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
              std::make_pair(dataset_key, ONE_BYTE_IMAGE_PIXEL_DATASET)));
          break;
        }
        case TWO_BYTE_IMAGE_PIXEL_DATASET :
        {
          dataset.reset(
              new TwoByteImagePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
              std::make_pair(dataset_key, TWO_BYTE_IMAGE_PIXEL_DATASET)));
          break;
        }
        case FOUR_BYTE_IMAGE_PIXEL_DATASET :
        {
          dataset.reset(
              new FourByteImagePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
              std::make_pair(dataset_key, FOUR_BYTE_IMAGE_PIXEL_DATASET)));
          break;
        }
        case ONE_BYTE_VOLUME_PIXEL_DATASET :
        {
          dataset.reset(
              new OneByteVolumePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
                             std::make_pair(dataset_key, ONE_BYTE_VOLUME_PIXEL_DATASET)));
          break;
        }
        case TWO_BYTE_VOLUME_PIXEL_DATASET :
        {
          dataset.reset(
              new TwoByteVolumePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
                             std::make_pair(dataset_key, TWO_BYTE_VOLUME_PIXEL_DATASET)));
          break;
        }
        case FOUR_BYTE_VOLUME_PIXEL_DATASET :
        {
          dataset.reset(
              new FourByteVolumePixelDataset(dataset_key));
          new_dataset_keys_and_types.insert(
              std::make_pair(output_datasets_iter->first,
              std::make_pair(dataset_key, FOUR_BYTE_VOLUME_PIXEL_DATASET)));
          break;
        }
        case MATRIX_DATASET :
        {
          //TODO
          break;
        }
        default :
        {
          continue;
        }
      }
      
      dataset_pointer_map_.insert(std::make_pair(dataset_key, dataset));
      dataset_filename_map_.insert(std::make_pair(dataset_key, std::string()));
          
      configuration->registerDataset(
          output_datasets_iter->first, dataset);
    }
  }

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

  slice_type Controller::datasetPartToSliceType(dataset_part_type dataset_part)
  {
    switch (dataset_part)
    {
      case AXIAL_SLICE_PART :
      {
        return(AXIAL_SLICE);
      }
      case CORONAL_SLICE_PART :
      {
        return(CORONAL_SLICE);
      }
      case SAGITTAL_SLICE_PART :
      {
        return(SAGITTAL_SLICE);
      }
      default :
      {
        return(UNDEF_SLICE);
      }
    }
  }
  
  //--------------------------------------------------
  // public slots
  //--------------------------------------------------
  
  void Controller::datasetChangedSlot(dataset_key_type const& dataset_key)
  {
    data_view_mediator_.updateDataChanged(dataset_key, DATASET_ATTRIBUTE_DATA);
  }
  
} // namespace imedgine

---