data_view_mediator.cpp

Go to the documentation of this file.

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

#include "data_view_mediator.h"

#include "controller.h"
#include "../viewer/spatial_pixel_view.h"
#include "../viewer/xy_slice_view.h"
#include "../viewer/yz_slice_view.h"
#include "../viewer/xz_slice_view.h"
#include "../viewer/image_pixel_view.h"
#include "../viewer/meta_volume_pixel_view.h"

namespace imedgine 
{

  DataViewMediator::DataViewMediator()
  {
    view_factory_.registerViewType<XYSliceView>(XY_SLICE_VIEW);
    view_factory_.registerViewType<YZSliceView>(YZ_SLICE_VIEW);
    view_factory_.registerViewType<XZSliceView>(XZ_SLICE_VIEW);
    view_factory_.registerViewType<SpatialPixelView>(VOXEL_VIEW);
    view_factory_.registerViewType<ImagePixelView>(IMAGE_PIXEL_VIEW);
    view_factory_.registerViewType<MetaVolumePixelView>(META_VOLUME_PIXEL_VIEW);
  }
  
  //--------------------------------------------------
  
  DataViewMediator::~DataViewMediator()
  {
#ifdef DEBUG
    std::cout << "Deleting DataViewMediator" << std::endl;
#endif
  }

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

  void DataViewMediator::registerViewOfDataset(
      dataset_pointer_type dataset, view_pointer_type view) 
      throw(NullPointerException)
  {
    if ((dataset.get() == 0) || (view.get() == 0))
    {
      throw (NullPointerException("DataViewMediator::registerViewOfDataset"));
    }
  
    view->registerDataViewMediator(this);
    view->setDataset(dataset);
    dataset_to_view_mmap_.insert(std::make_pair(dataset->getDatasetKey(), view));
  }
  
  //---------------------------------------------------
  
  view_pointer_type DataViewMediator::getViewOfDataset(
      dataset_pointer_type dataset, view_type type)
      throw(NullPointerException)   
  {
    if (dataset.get() == 0)
    {
      throw (NullPointerException("DataViewMediator::getViewOfDataset"));
    }
    
    // get the dependent views of the given dataset
    std::pair<dataset_to_view_mmap_iterator_type,
    dataset_to_view_mmap_iterator_type> dependent_views_range =
        dataset_to_view_mmap_.equal_range(dataset->getDatasetKey());

    for ( ; dependent_views_range.first != 
            dependent_views_range.second; 
            ++dependent_views_range.first)
    {
      if (dependent_views_range.first->second.get() == 0)    
      {
        throw (NullPointerException("DataViewMediator::getViewOfDataset"));    
      }
       
      if (dependent_views_range.first->second->getType() == type)
      {
        view_pointer_type view(dependent_views_range.first->second->clone());
        if (view.get() == 0)
        {
          throw (NullPointerException("DataViewMediator::getViewOfDataset"));
        }            
        registerViewOfDataset(dataset, view);
        return(view);
      }      
    }
     
    view_pointer_type view(view_factory_.getView(type));
    
    if (view.get() == 0)
    {
      throw (NullPointerException("DataViewMediator::getViewOfDataset"));
    }        
    
    registerViewOfDataset(dataset, view);
    
    return(view);     
  }
  
  //---------------------------------------------------
   
  void DataViewMediator::getDependentViewIDsOfDataset(
      dataset_key_type dataset_key, view_id_container_type& target_container) const
      throw(NullPointerException)
  {
        // get the dependent views of the given dataset
    std::pair<dataset_to_view_mmap_const_iterator_type,
    dataset_to_view_mmap_const_iterator_type> dependent_views_range =
        dataset_to_view_mmap_.equal_range(dataset_key);
    
    for ( ; dependent_views_range.first != dependent_views_range.second; 
            ++dependent_views_range.first)
    {
      if (dependent_views_range.first->second.get() == 0)
      {
        throw (NullPointerException("DataViewMediator::getDependentViewIDsOfDataset"));
      } 
      target_container.push_back(dependent_views_range.first->second->getViewID());
    }
  }
  
 //--------------------------------------------------
   
  bool DataViewMediator::deleteView(unsigned int view_id)
      throw(NullPointerException)   
  {    
    for (dataset_to_view_mmap_iterator_type view_iter = 
         dataset_to_view_mmap_.begin(); 
         view_iter != dataset_to_view_mmap_.end(); ++view_iter)
    {
      if (view_iter->second.get() == 0)
      {
        throw (NullPointerException("DataViewMediator::deleteView"));
      }        
      if (view_iter->second->getViewID() == view_id)
      {    
        view_iter->second->deregisterDataViewMediator(); 
        dataset_to_view_mmap_.erase(view_iter);
        return(true);
      } 
    }
    return(false);
      
  }     
  
  //--------------------------------------------------
    
  bool DataViewMediator::removeDataset(
      dataset_key_type dataset_key)  
  {
    dataset_to_dataset_mmap_iterator_type locked_datasets_iter;
     
    while ((locked_datasets_iter = dataset_to_dataset_mmap_.find(dataset_key)) != 
            dataset_to_dataset_mmap_.end())
    {
      dataset_key_type locked_dataset_key = locked_datasets_iter->second;
      
      dataset_to_dataset_mmap_.erase(locked_datasets_iter);
      
      std::pair<dataset_to_dataset_mmap_iterator_type, 
      dataset_to_dataset_mmap_iterator_type> locked_datasets_range =
          dataset_to_dataset_mmap_.equal_range(locked_dataset_key);
      
      for ( ; locked_datasets_range.first != locked_datasets_range.second; 
              ++locked_datasets_range.first)
      { 
        if (locked_datasets_range.first->second == dataset_key)
        {
          dataset_to_dataset_mmap_.erase(locked_datasets_iter);
          break;
        }
      }
    }
    
    for (dataset_to_view_mmap_iterator_type view_iter = 
         dataset_to_view_mmap_.begin(); 
         view_iter != dataset_to_view_mmap_.end(); ++view_iter)
    {
      view_iter->second->onDatasetDeletion(dataset_key);
    }
    
    return(dataset_to_view_mmap_.erase(dataset_key) > 0);
  } 
  
  //--------------------------------------------------
  
  void DataViewMediator::lockDatasets(dataset_key_type dataset_left, 
                    dataset_key_type dataset_right) 
  {
    std::pair<dataset_to_dataset_mmap_iterator_type,
    dataset_to_dataset_mmap_iterator_type> locked_datasets_range = 
        dataset_to_dataset_mmap_.equal_range(dataset_left);
        
    for ( ; locked_datasets_range.first != locked_datasets_range.second; 
            ++locked_datasets_range.first)
    {
      if (locked_datasets_range.first->second == dataset_right)
      {
        // datasets already locked -> nothing to do
        return;
      }
    }
    
    // map the locked dataset keys to each other with an initial lock reference count of 1
    dataset_to_dataset_mmap_.insert(
        std::make_pair(dataset_left, dataset_right));
    dataset_to_dataset_mmap_.insert(
        std::make_pair(dataset_right, dataset_left));
  }
  
  //--------------------------------------------------
  
  void DataViewMediator::unlockDatasets(dataset_key_type dataset_left, 
                                      dataset_key_type dataset_right) 
  {
    std::pair<dataset_to_dataset_mmap_iterator_type,
    dataset_to_dataset_mmap_iterator_type> locked_datasets_range = 
        dataset_to_dataset_mmap_.equal_range(dataset_left);
        
    for ( ; locked_datasets_range.first != locked_datasets_range.second; 
            ++locked_datasets_range.first)
    {
      if (locked_datasets_range.first->second == dataset_right)
      {
        dataset_to_dataset_mmap_.erase(locked_datasets_range.first);
        break;
      }
    }
    
    locked_datasets_range = dataset_to_dataset_mmap_.equal_range(dataset_right);
        
    for ( ; locked_datasets_range.first != locked_datasets_range.second; 
            ++locked_datasets_range.first)
    {
      if (locked_datasets_range.first->second == dataset_left)
      {
        dataset_to_dataset_mmap_.erase(locked_datasets_range.first);
        break;
      }
    }
  }
  
  //--------------------------------------------------
  
  bool DataViewMediator::areDatasetsLocked(dataset_key_type dataset_left, 
                         dataset_key_type dataset_right)
  {
    std::pair<dataset_to_dataset_mmap_iterator_type,
    dataset_to_dataset_mmap_iterator_type> locked_datasets_range = 
        dataset_to_dataset_mmap_.equal_range(dataset_left);
        
    for ( ; locked_datasets_range.first != locked_datasets_range.second; 
            ++locked_datasets_range.first)
    {
      if (locked_datasets_range.first->second == dataset_right)
      {
        return(true);
      }
    }
     
    return(false);
  }
  
  //--------------------------------------------------
  
  void DataViewMediator::updateDependentViews(dataset_key_type dataset)
      throw(NullPointerException)   
  {    
    // get the dependent views of the given dataset
    std::pair<dataset_to_view_mmap_iterator_type,
    dataset_to_view_mmap_iterator_type> dependent_views_range =
        dataset_to_view_mmap_.equal_range(dataset);

    for ( ; dependent_views_range.first != 
            dependent_views_range.second; 
            ++dependent_views_range.first)
    {
      if (dependent_views_range.first->second.get() == 0)
      {
        throw (NullPointerException("DataViewMediator::updateDependentViews"));
      } 
      dependent_views_range.first->second->updateView(); 
    }
  }
  
  //--------------------------------------------------
  
  void DataViewMediator::updateDataChanged(dataset_key_type dataset, 
                                           dataset_attribute_type changed_attribute)
      throw(NullPointerException, InvalidCastException)   
  {    
    // get the dependent views of the given dataset
    std::pair<dataset_to_view_mmap_iterator_type,
    dataset_to_view_mmap_iterator_type> dependent_views_range =
        dataset_to_view_mmap_.equal_range(dataset);

    for ( ; dependent_views_range.first != 
            dependent_views_range.second; 
            ++dependent_views_range.first)
    {
      if (dependent_views_range.first->second.get() == 0)
      {
        throw (NullPointerException("DataViewMediator::updateDataChanged"));
      }
      dependent_views_range.first->second->onDataChangedEvent(changed_attribute);
    }
    
        // get the datasets locked with the given dataset
    std::pair<dataset_to_dataset_mmap_iterator_type, 
    dataset_to_dataset_mmap_iterator_type> locked_datasets_range =
        dataset_to_dataset_mmap_.equal_range(dataset);
    
    for ( ; locked_datasets_range.first != locked_datasets_range.second; 
            ++locked_datasets_range.first)
    { 
      switch (changed_attribute)
      {
        case DATASET_ATTRIBUTE_INTENSITY :
        {
          // set the intensity of the locked datasets to the 
          // intensity of the given dataset
          try
          {
            pixel_dataset_pointer_type changed_dataset( 
              Controller::getInstance().getDataset(dataset), 
                boost::detail::dynamic_cast_tag());
            pixel_dataset_pointer_type locked_dataset( 
              Controller::getInstance().getDataset(locked_datasets_range.first->second), 
                boost::detail::dynamic_cast_tag());
            
            if ((changed_dataset.get() == 0) || (locked_dataset.get() == 0))
            {
              throw(InvalidCastException("DataViewMediator::updateDataChanged", 
                    "dataset_pointer_type", "pixel_dataset_pointer_type"));
            }
            
            locked_dataset->setIntensity(
                changed_dataset->getIntensityWindow(), changed_dataset->getIntensityLevel());
            break;
          }
          catch (DatasetNotFoundException const&)
          {
            dataset_to_dataset_mmap_.erase(locked_datasets_range.first);
            continue;
          }
        }
        case DATASET_ATTRIBUTE_FOCUS_POINT :
        {
          try
          {
            pixel_dataset_pointer_type changed_dataset( 
              Controller::getInstance().getDataset(dataset), 
                boost::detail::dynamic_cast_tag());
            pixel_dataset_pointer_type locked_dataset( 
              Controller::getInstance().getDataset(locked_datasets_range.first->second), 
                boost::detail::dynamic_cast_tag());
            
            if ((changed_dataset.get() == 0) || (locked_dataset.get() == 0))
            {
              throw(InvalidCastException("DataViewMediator::updateDataChanged", 
                    "dataset_pointer_type", "pixel_dataset_pointer_type"));
            }
          
            locked_dataset->setFocusPoint(changed_dataset->getFocusPoint());
          }
          catch (DatasetNotFoundException const&)
          {
            dataset_to_dataset_mmap_.erase(locked_datasets_range.first);
            continue; 
          }  
        }
        default :
        {
          break;
        }
      }

      // get the dependent view of the locked dataset
      dependent_views_range = 
          dataset_to_view_mmap_.equal_range(
          locked_datasets_range.first->second);
      
      // notify all of them
      for ( ; dependent_views_range.first != 
              dependent_views_range.second; 
              ++dependent_views_range.first)
      {
        if (dependent_views_range.first->second.get() == 0)
        {
          throw (NullPointerException("DataViewMediator::updateFocusPointChanged"));
        } 
        dependent_views_range.first->second->onDataChangedEvent(changed_attribute);
      }
    }
    
    //TODO: notify the gui (via the controller) of the event
  }
  
  //--------------------------------------------------
  
//   void DataViewMediator::updateFocusPointChanged(dataset_key_type dataset)
//       throw(NullPointerException)   
//   {  
//     // get the dependent views of the given dataset
//     std::pair<dataset_to_view_mmap_iterator_type,
//     dataset_to_view_mmap_iterator_type> dependent_views_range =
//         dataset_to_view_mmap_.equal_range(dataset);
// 
//     // notify all of them
//     for (dataset_to_view_mmap_iterator_type dataset_iter = 
//          dataset_to_view_mmap_.lower_bound(dataset);
//          dataset_iter != dataset_to_view_mmap_.upper_bound(dataset); 
//             ++dataset_iter)
//     {
//       if (dataset_iter->second.get() == 0)
//       {
//         throw (NullPointerException("DataViewMediator::updateFocusPointChanged"));    
//       }
//       
//       dataset_iter->second->onFocusPointChangedEvent();    
//     }
//   
//     // get the datasets locked with the given dataset
//     std::pair<dataset_to_dataset_mmap_iterator_type, 
//     dataset_to_dataset_mmap_iterator_type> locked_datasets_range =
//         dataset_to_dataset_mmap_.equal_range(dataset);
//     
//     for ( ; locked_datasets_range.first != locked_datasets_range.second; 
//             ++locked_datasets_range.first)
//     { 
//       try
//       {     
//         // set the focus point of the locked datasets to the 
//         // focus point of the given dataset
//         Controller::getInstance().getDataset(locked_datasets_range.first->second)->setFocusPoint(
//             Controller::getInstance().getDataset(dataset)->getFocusPoint());
//       }
//       catch (DatasetNotFoundException const&)
//       {
//         dataset_to_dataset_mmap_.erase(locked_datasets_range.first);
//         continue; 
//       }
//       
//       // get the dependent view of the locked dataset
//       dependent_views_range = 
//           dataset_to_view_mmap_.equal_range(
//           locked_datasets_range.first->second);
//       
//       // notify all of them
//       for ( ; dependent_views_range.first != 
//               dependent_views_range.second; 
//               ++dependent_views_range.first)
//       {
//         if (dependent_views_range.first->second.get() == 0)
//         {
//           throw (NullPointerException("DataViewMediator::updateFocusPointChanged"));
//         } 
//         dependent_views_range.first->second->onFocusPointChangedEvent();
//       }
//     }
//   }
} // namespace imedgine

---