mitk: mitkLevelWindowManager.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 
00019 #include "mitkLevelWindowManager.h"
00020 #include <itkCommand.h>
00021 #include "mitkDataStorage.h"
00022 #include "mitkNodePredicateBase.h"
00023 #include "mitkNodePredicateProperty.h"
00024 #include "mitkNodePredicateDataType.h"
00025 #include "mitkNodePredicateAnd.h"
00026 #include "mitkNodePredicateOr.h"
00027 #include "mitkNodePredicateNot.h"
00028 #include "mitkProperties.h"
00029 #include "mitkMessage.h"
00030 
00031 
00032 mitk::LevelWindowManager::LevelWindowManager()
00033 : m_DataStorage(NULL), m_LevelWindowProperty(NULL), m_AutoTopMost(true),
00034   m_IsObserverTagSet(false), m_CurrentImage(NULL),m_IsPropertyModifiedTagSet(false)
00035 {
00036 }
00037 
00038 
00039 mitk::LevelWindowManager::~LevelWindowManager()
00040 {
00041   if (m_DataStorage.IsNotNull())
00042   {
00043     m_DataStorage->AddNodeEvent.RemoveListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageChanged ));
00044     m_DataStorage->RemoveNodeEvent.RemoveListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
00045     m_DataStorage = NULL;
00046   }
00047   if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull())
00048   {
00049     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
00050     m_IsPropertyModifiedTagSet = false;
00051   }
00052   for( std::map<unsigned long, mitk::BaseProperty::Pointer>::iterator iter = m_PropObserverToNode.begin(); iter != m_PropObserverToNode.end(); iter++ ) {
00053     (*iter).second->RemoveObserver((*iter).first);
00054   }
00055   for( std::map<unsigned long, mitk::BaseProperty::Pointer>::iterator iter = m_PropObserverToNode2.begin(); iter != m_PropObserverToNode2.end(); iter++ ) {
00056     (*iter).second->RemoveObserver((*iter).first);
00057   }
00058 }
00059 
00060 
00061 void mitk::LevelWindowManager::SetDataStorage( mitk::DataStorage* ds )
00062 {
00063   if (ds == NULL)
00064     return;
00065 
00066   /* remove listeners of old DataStorage */
00067   if (m_DataStorage.IsNotNull())
00068   {
00069     m_DataStorage->AddNodeEvent.RemoveListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageChanged ));
00070     m_DataStorage->RemoveNodeEvent.RemoveListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
00071   }
00072   /* register listener for new DataStorage */
00073   m_DataStorage = ds;  // register 
00074   m_DataStorage->AddNodeEvent.AddListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageChanged ));
00075   m_DataStorage->RemoveNodeEvent.AddListener(MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
00076   this->DataStorageChanged(); // update us with new DataStorage
00077 }
00078 
00079 
00080 void mitk::LevelWindowManager::OnPropertyModified(const itk::EventObject& )
00081 {
00082   Modified();
00083 }
00084 
00085 
00086 void mitk::LevelWindowManager::SetAutoTopMostImage(bool autoTopMost, const mitk::DataNode* removedNode)
00087 {
00088   m_AutoTopMost = autoTopMost;
00089   if (m_AutoTopMost == false)
00090     return;
00091 
00092   if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull())
00093   {
00094     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
00095     m_IsPropertyModifiedTagSet = false;
00096   }
00097   /* search topmost image */
00098   if (m_DataStorage.IsNull())
00099   {
00100     itkExceptionMacro("DataStorage not set");
00101   }
00102   int maxLayer = itk::NumericTraits<int>::min();
00103   m_LevelWindowProperty = NULL;
00104 
00105   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
00106   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
00107   {
00108     mitk::DataNode::Pointer node = it->Value();
00109     if (node.IsNull() || (removedNode != NULL && node == removedNode))
00110       continue;
00111     if (node->IsVisible(NULL) == false)
00112       continue;
00113     int layer = 0;
00114     node->GetIntProperty("layer", layer);
00115     if ( layer < maxLayer )
00116       continue;
00117     mitk::LevelWindowProperty::Pointer levelWindowProperty = dynamic_cast<mitk::LevelWindowProperty*>(node->GetProperty("levelwindow"));
00118     if (levelWindowProperty.IsNull())
00119       continue;
00120     m_LevelWindowProperty = levelWindowProperty;
00121     m_CurrentImage = dynamic_cast<mitk::Image*>(node->GetData());
00122     maxLayer = layer;
00123   }
00124   Modified();
00125 }
00126 
00127 // sets an specific LevelWindowProperty, all changes will affect the image belonging to this property.
00128 // sets m_AutoTopMost to false
00129 void mitk::LevelWindowManager::SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty)
00130 {
00131   if (levelWindowProperty.IsNull())
00132     return;
00133 
00134   if (m_IsPropertyModifiedTagSet)  // remove listener for old property
00135   {
00136     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
00137     m_IsPropertyModifiedTagSet = false;
00138   }
00139   m_LevelWindowProperty = levelWindowProperty;
00140 
00141   itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();  // register listener for new property
00142   command->SetCallbackFunction(this, &LevelWindowManager::OnPropertyModified);
00143   m_PropertyModifiedTag = m_LevelWindowProperty->AddObserver( itk::ModifiedEvent(), command );
00144   m_IsPropertyModifiedTagSet = true;
00145   m_AutoTopMost = false;
00146 
00147   /* search image than belongs to the property */
00148   mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("levelwindow", m_LevelWindowProperty);
00149   mitk::DataNode* n = m_DataStorage->GetNode(p);
00150   if (n == NULL)
00151   {
00152     itkExceptionMacro("No Image in DataStorage that belongs to LevelWindow property " << m_LevelWindowProperty);
00153   }
00154   m_CurrentImage = dynamic_cast<mitk::Image*>(n->GetData());
00155   this->Modified();
00156 }
00157 
00158 
00159 // returns the current mitkLevelWindowProperty object from the image that is affected by changes
00160 mitk::LevelWindowProperty::Pointer mitk::LevelWindowManager::GetLevelWindowProperty()
00161 {
00162   return m_LevelWindowProperty;
00163 }
00164 
00165 
00166 // returns Level/Window values for the current image
00167 const mitk::LevelWindow& mitk::LevelWindowManager::GetLevelWindow()
00168 {
00169   if (m_LevelWindowProperty.IsNotNull())
00170     return m_LevelWindowProperty->GetLevelWindow();
00171   else
00172   {
00173     itkExceptionMacro("No LevelWindow available!");
00174   }
00175 }
00176 
00177 // sets new Level/Window values and informs all listeners about changes
00178 void mitk::LevelWindowManager::SetLevelWindow(const mitk::LevelWindow& levelWindow)
00179 {
00180   if (m_LevelWindowProperty.IsNotNull())
00181   {
00182     m_LevelWindowProperty->SetLevelWindow(levelWindow);
00183   }
00184   this->Modified();
00185 }
00186 
00187 void mitk::LevelWindowManager::DataStorageChanged( const mitk::DataNode* )
00188 {
00189   this->DataStorageRemovedNode();
00190 }
00191 void mitk::LevelWindowManager::DataStorageRemovedNode( const mitk::DataNode* removedNode )
00192 {
00193   /* remove old observers */
00194   for (ObserverToPropertyMap::iterator iter = m_PropObserverToNode.begin(); iter != m_PropObserverToNode.end(); iter++ ) 
00195     (*iter).second->RemoveObserver((*iter).first);
00196   m_PropObserverToNode.clear();
00197 
00198   for (ObserverToPropertyMap::iterator iter = m_PropObserverToNode2.begin(); iter != m_PropObserverToNode2.end(); iter++ ) 
00199     (*iter).second->RemoveObserver((*iter).first);
00200   m_PropObserverToNode2.clear();
00201 
00202   if (m_DataStorage.IsNull())
00203   {
00204     itkExceptionMacro("DataStorage not set");
00205   }
00206 
00207   /* listen to changes  in visible property of all images */
00208 
00209   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
00210   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
00211   {
00212     if (it->Value().IsNull())
00213       continue;
00214     /* register listener for changes in visible property */
00215     itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();
00216     command->SetCallbackFunction(this, &LevelWindowManager::Update);
00217     m_PropObserverToNode[it->Value()->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command )] = it->Value()->GetProperty("visible");
00218   }
00219 
00220   /* listen to changes  in layer property of all images */
00221 
00222   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
00223   {
00224     if (it->Value().IsNull())
00225       continue;
00226     /* register listener for changes in layer property */
00227     itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command2 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
00228     command2->SetCallbackFunction(this, &LevelWindowManager::Update);
00229     m_PropObserverToNode2[it->Value()->GetProperty("layer")->AddObserver( itk::ModifiedEvent(), command2 )] = it->Value()->GetProperty("layer");
00230   }
00231 
00232   /* search image than belongs to the property */
00233   if (m_LevelWindowProperty.IsNull())
00234     SetAutoTopMostImage(true, removedNode);
00235   else
00236   {
00237     mitk::NodePredicateProperty::Pointer p2 = mitk::NodePredicateProperty::New("levelwindow", m_LevelWindowProperty);
00238     mitk::DataNode* n = m_DataStorage->GetNode(p2);
00239     if (n == NULL || m_AutoTopMost) // if node was deleted, change our behaviour to AutoTopMost, if AutoTopMost is true change level window to topmost node
00240       SetAutoTopMostImage(true, removedNode);
00241    }
00242 }
00243 
00244 
00245 mitk::DataStorage* mitk::LevelWindowManager::GetDataStorage()
00246 {
00247   return m_DataStorage.GetPointer();
00248 }
00249 
00250 
00251 // true if changes on slider or line-edits will affect always the topmost layer image
00252 bool mitk::LevelWindowManager::isAutoTopMost()
00253 {
00254   return m_AutoTopMost;
00255 }
00256 
00257 
00258 void mitk::LevelWindowManager::Update(const itk::EventObject&)  // visible property of a image has changed
00259 {
00260   if (m_AutoTopMost)
00261   {
00262     SetAutoTopMostImage(true);
00263     return;
00264   }
00265   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
00266   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
00267   {
00268     mitk::DataNode::Pointer node = it->Value();
00269     if (node.IsNull())
00270       continue;
00271     if (node->IsVisible(NULL) == false)
00272       continue;
00273     mitk::LevelWindowProperty::Pointer levelWindowProperty = dynamic_cast<mitk::LevelWindowProperty*>(node->GetProperty("levelwindow"));
00274     if (levelWindowProperty.IsNull())
00275       continue;
00276     m_LevelWindowProperty = levelWindowProperty;
00277     m_CurrentImage = dynamic_cast<mitk::Image*>(node->GetData());
00278     if (m_LevelWindowProperty.IsNull() && m_LevelWindowProperty.GetPointer() == levelWindowProperty) // we found our m_LevelWindowProperty
00279     {
00280       return;
00281     }
00282   }
00283   Modified();
00284 }
00285 
00286 
00287 mitk::DataStorage::SetOfObjects::ConstPointer mitk::LevelWindowManager::GetRelevantNodes()
00288 {
00289   if (m_DataStorage.IsNull())
00290     return mitk::DataStorage::SetOfObjects::ConstPointer(mitk::DataStorage::SetOfObjects::New());  // return empty set
00291 
00292   mitk::BoolProperty::Pointer trueProp = mitk::BoolProperty::New(true);
00293   mitk::NodePredicateProperty::Pointer notBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(false));
00294   mitk::NodePredicateProperty::Pointer hasLevelWindow = mitk::NodePredicateProperty::New("levelwindow", NULL);
00295   
00296   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
00297   mitk::NodePredicateDataType::Pointer isDImage = mitk::NodePredicateDataType::New("DiffusionImage");
00298   mitk::NodePredicateDataType::Pointer isTImage = mitk::NodePredicateDataType::New("TensorImage");
00299   mitk::NodePredicateDataType::Pointer isQImage = mitk::NodePredicateDataType::New("QBallImage");
00300   mitk::NodePredicateOr::Pointer predicateTypes = mitk::NodePredicateOr::New();
00301   predicateTypes->AddPredicate(isImage);
00302   predicateTypes->AddPredicate(isDImage);
00303   predicateTypes->AddPredicate(isTImage);
00304   predicateTypes->AddPredicate(isQImage);
00305   
00306   mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New();
00307   predicate->AddPredicate(notBinary);
00308   predicate->AddPredicate(hasLevelWindow); 
00309   predicate->AddPredicate(predicateTypes);
00310 
00311   mitk::DataStorage::SetOfObjects::ConstPointer relevantNodes = m_DataStorage->GetSubset( predicate );
00312   return relevantNodes; 
00313 }
00314 
00315 
00316 mitk::Image* mitk::LevelWindowManager::GetCurrentImage()
00317 {
00318   return m_CurrentImage;
00319 }