diff --git a/Modules/Core/include/mitkLevelWindowManager.h b/Modules/Core/include/mitkLevelWindowManager.h index 92768c692c..aedd51c4c7 100644 --- a/Modules/Core/include/mitkLevelWindowManager.h +++ b/Modules/Core/include/mitkLevelWindowManager.h @@ -1,203 +1,205 @@ /*============================================================================ 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 MITKLEVELWINDOWMANAGER_H #define MITKLEVELWINDOWMANAGER_H // mitk core #include "mitkBaseProperty.h" #include "mitkDataStorage.h" #include "mitkLevelWindowProperty.h" // c++ #include #include namespace mitk { /** @brief Provides access to the LevelWindowProperty object and LevelWindow of the "current" image. - provides a LevelWindowProperty for purposes like GUI editors - this property comes from one of two possible sources - either something (e.g. the application) sets the property because of some user selection - OR the "Auto top-most" logic is used to search a DataStorage for the image with the highest "layer" property value Changes on Level/Window can be set with SetLevelWindow() and will affect either the topmost layer image, - if isAutoTopMost() returns true, or an image which is set by SetLevelWindowProperty(LevelWindowProperty::Pointer + if IsAutoTopMost() returns true, or an image which is set by SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty). + Additionally the changes on Level/Window will affect one or multiple selected images, if IsSelectedImages() returns true. + Only one of the two different modes can be enabled at the same time. Changes to Level/Window, when another image gets active or by SetLevelWindow(const LevelWindow& levelWindow), will be sent to all listeners by Modified(). - DataStorageChanged() listens to the DataStorage for new or removed images. Depending on how m_AutoTopMost is set, + DataStorageChanged() listens to the DataStorage for new or removed images. Depending on the currently enabled mode, the new image becomes active or not. If an image is removed from the DataStorage and m_AutoTopMost is false, there is a check to proof, if the active image is still available. If not, then m_AutoTopMost becomes true. Note that this class is not thread safe at the moment! */ class MITKCORE_EXPORT LevelWindowManager : public itk::Object { public: mitkClassMacroItkParent(LevelWindowManager, itk::Object); itkFactorylessNewMacro(Self); itkCloneMacro(Self); void SetDataStorage(DataStorage* dataStorage); DataStorage *GetDataStorage(); /** * @brief (Re-)Initialize the LevelWindowManager by setting the topmost image. * Use the removedNode parameter if a node was removed. * * @param autoTopMost Set the topmost layer image to be affected by changes, if true. * @param removedNode A node was removed from the data storage if != nullptr. */ void SetAutoTopMostImage(bool autoTopMost, const DataNode *removedNode = nullptr); /** * @brief (Re-)Initialize the LevelWindowManager by setting the selected images. * Use the removedNode parameter if a node was removed. * * @param selectedImagesMode Set the selected images to be affected by changes, if true. * @param removedNode A node was removed from the data storage if != nullptr. */ void SetSelectedImages(bool selectedImagesMode, const DataNode *removedNode = nullptr); void RecalculateLevelWindowForSelectedComponent(const itk::EventObject&); /** * @brief Update the level window. * This function is called if a property of a data node is changed. * Relevant properties are defined in the protected 'ObserverToPropertyValueMap'-members. */ void Update(const itk::EventObject&); /** * @brief Update the level window. * This function is only called if the 'selected' property of a data node is changed. * This is done in order to avoid finding the correct image each time a node is selected but * the 'm_SelectedImages' bool value is set to false (as the normal 'Update'-function would do). * Changes of the 'selected' property happen quite a lot so this should not slow down the application. */ void UpdateSelected(const itk::EventObject&); /** * @brief Set a specific LevelWindowProperty; all changes will affect the image belonging to this property. * @throw mitk::Exception Throw an exception if the there is no image in the data storage which belongs to this * property. */ void SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty); /** * @brief Set new Level/Window values and inform all listeners about changes. */ void SetLevelWindow(const LevelWindow &levelWindow); /** * @brief Return the current LevelWindowProperty object from the image that is affected by changes. * * @return The current LevelWindowProperty */ - LevelWindowProperty::Pointer GetLevelWindowProperty(); + LevelWindowProperty::Pointer GetLevelWindowProperty() const; /** * @brief Return Level/Window values for the current image * * @return The LevelWindow value for the current image. */ - const LevelWindow &GetLevelWindow(); + const LevelWindow &GetLevelWindow() const; /** - * @brief Return true, if the changes on slider or line-edits will affect the topmost layer image. + * @brief Return true, if level window changes will affect the topmost layer image. * * @return Return the member value that denotes the auto-topmost mode. */ - bool IsAutoTopMost(); + bool IsAutoTopMost() const; /** - * @brief Return true, if changes on slider or line-edits will affect the currently selected images. + * @brief Return true, if level window changes will affect the currently selected images. * * @return Return the member value that denotes the selected-images mode. */ - bool IsSelectedImages(); + bool IsSelectedImages() const; /** * @brief This method is called when a node is added to the data storage. * A listener on the data storage is used to call this method automatically after a node was added. * @throw mitk::Exception Throws an exception if something is wrong, e.g. if the number of observers differs from * the number of nodes. */ void DataStorageAddedNode(const DataNode *dataNode = nullptr); /** * @brief This method is called when a node is removed from the data storage. * A listener on the data storage is used to call this method automatically before a node will be removed. * @throw mitk::Exception Throws an exception if something is wrong, e.g. if the number of observers differs from * the number of nodes. */ void DataStorageRemovedNode(const DataNode *dataNode = nullptr); /** * @brief Change notifications from mitkLevelWindowProperty. */ void OnPropertyModified(const itk::EventObject&); /** * @brief Return the currently active image. * * @return The member variable holding the currently active image. */ - Image *GetCurrentImage(); + Image *GetCurrentImage() const; /** * @brief Return the number of observers for data node's "visible" property. * This basically returns the number of relevant nodes to observe. * * @return The current number of observers which are registered in this object. */ - int GetNumberOfObservers(); + int GetNumberOfObservers() const; /** * @brief Return all nodes in the data storage that have the following properties: * - "binary" == false * - "levelwindow" * - DataType == Image / DiffusionImage / TensorImage / OdfImage / ShImage * @ return The filtered list of relevant nodes in the data storage */ - DataStorage::SetOfObjects::ConstPointer GetRelevantNodes(); + DataStorage::SetOfObjects::ConstPointer GetRelevantNodes() const; private: LevelWindowManager(); ~LevelWindowManager() override; DataStorage::Pointer m_DataStorage; LevelWindowProperty::Pointer m_LevelWindowProperty; typedef std::pair PropDataPair; typedef std::map ObserverToPropertyValueMap; ObserverToPropertyValueMap m_ObserverToVisibleProperty; ObserverToPropertyValueMap m_ObserverToLayerProperty; ObserverToPropertyValueMap m_ObserverToRenderingModeProperty; ObserverToPropertyValueMap m_ObserverToDisplayedComponentProperty; ObserverToPropertyValueMap m_ObserverToLevelWindowImageProperty; ObserverToPropertyValueMap m_ObserverToSelectedProperty; void UpdateObservers(); void ClearPropertyObserverMaps(); void CreatePropertyObserverMaps(); - bool HasLevelWindowRenderingMode(DataNode *dataNode); + bool HasLevelWindowRenderingMode(DataNode *dataNode) const; // This variable holds a data node which will be deleted from the datastorage immediately. const DataNode *m_NodeMarkedToDelete; bool m_AutoTopMost; bool m_SelectedImagesMode; unsigned long m_PropertyModifiedTag; Image *m_CurrentImage; std::vector m_DataNodesForLevelWindow; bool m_IsPropertyModifiedTagSet; bool m_LevelWindowMutex; }; } #endif // MITKLEVELWINDOWMANAGER_H diff --git a/Modules/Core/src/DataManagement/mitkLevelWindowManager.cpp b/Modules/Core/src/DataManagement/mitkLevelWindowManager.cpp index 109716cbd2..d67daa36e3 100644 --- a/Modules/Core/src/DataManagement/mitkLevelWindowManager.cpp +++ b/Modules/Core/src/DataManagement/mitkLevelWindowManager.cpp @@ -1,724 +1,723 @@ /*============================================================================ 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. ============================================================================*/ #include "mitkLevelWindowManager.h" -#include "mitkDataStorage.h" + #include "mitkImage.h" #include "mitkMessage.h" #include "mitkNodePredicateAnd.h" #include "mitkNodePredicateBase.h" #include "mitkNodePredicateDataType.h" #include "mitkNodePredicateNot.h" #include "mitkNodePredicateOr.h" #include "mitkNodePredicateProperty.h" #include "mitkProperties.h" #include "mitkRenderingModeProperty.h" #include mitk::LevelWindowManager::LevelWindowManager() : m_DataStorage(nullptr) , m_LevelWindowProperty(nullptr) , m_AutoTopMost(true) , m_SelectedImagesMode(false) , m_CurrentImage(nullptr) , m_IsPropertyModifiedTagSet(false) , m_LevelWindowMutex(false) { } mitk::LevelWindowManager::~LevelWindowManager() { if (m_DataStorage.IsNotNull()) { m_DataStorage->AddNodeEvent.RemoveListener( MessageDelegate1(this, &LevelWindowManager::DataStorageAddedNode)); m_DataStorage->RemoveNodeEvent.RemoveListener( MessageDelegate1(this, &LevelWindowManager::DataStorageRemovedNode)); m_DataStorage = nullptr; } if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull()) { m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag); m_IsPropertyModifiedTagSet = false; } this->ClearPropertyObserverMaps(); } void mitk::LevelWindowManager::SetDataStorage(DataStorage *dataStorage) { if (nullptr == dataStorage) return; // remove listeners of old DataStorage if (m_DataStorage.IsNotNull()) { m_DataStorage->AddNodeEvent.RemoveListener( MessageDelegate1(this, &LevelWindowManager::DataStorageAddedNode)); m_DataStorage->RemoveNodeEvent.RemoveListener( MessageDelegate1(this, &LevelWindowManager::DataStorageRemovedNode)); } // register listener for new DataStorage m_DataStorage = dataStorage; m_DataStorage->AddNodeEvent.AddListener( MessageDelegate1(this, &LevelWindowManager::DataStorageAddedNode)); m_DataStorage->RemoveNodeEvent.AddListener( MessageDelegate1(this, &LevelWindowManager::DataStorageRemovedNode)); this->DataStorageAddedNode(); } mitk::DataStorage *mitk::LevelWindowManager::GetDataStorage() { return m_DataStorage.GetPointer(); } void mitk::LevelWindowManager::SetAutoTopMostImage(bool autoTopMost, const DataNode *removedNode/* = nullptr*/) { m_AutoTopMost = autoTopMost; if (false == m_AutoTopMost) { return; } // deactivate other mode m_SelectedImagesMode = false; if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull()) { m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag); m_IsPropertyModifiedTagSet = false; } // find topmost image in the data storage if (m_DataStorage.IsNull()) { mitkThrow() << "DataStorage not set"; } DataNode::Pointer topLevelNode; int maxVisibleLayer = itk::NumericTraits::min(); m_LevelWindowProperty = nullptr; m_CurrentImage = nullptr; DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull() || node == removedNode) { continue; } // reset the "imageForLevelWindow" of each node m_LevelWindowMutex = true; node->SetBoolProperty("imageForLevelWindow", false); m_LevelWindowMutex = false; if (false == node->IsVisible(nullptr)) { continue; } bool validRenderingMode = HasLevelWindowRenderingMode(node); if (false == validRenderingMode) { continue; } int layer = -1; node->GetIntProperty("layer", layer); - if (layer < maxVisibleLayer) + if (layer <= maxVisibleLayer) { continue; } m_LevelWindowProperty = dynamic_cast(node->GetProperty("levelwindow")); topLevelNode = node; maxVisibleLayer = layer; } // this will set the "imageForLevelWindow" property and the 'm_CurrentImage' and call 'Modified()' this->SetLevelWindowProperty(m_LevelWindowProperty); if (m_LevelWindowProperty.IsNull()) { this->Modified(); } } void mitk::LevelWindowManager::SetSelectedImages(bool selectedImagesMode, const DataNode *removedNode/* = nullptr*/) { m_SelectedImagesMode = selectedImagesMode; if (false == m_SelectedImagesMode) { return; } // deactivate other mode m_AutoTopMost = false; if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull()) { m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag); m_IsPropertyModifiedTagSet = false; } // find selected images in the data storage if (m_DataStorage.IsNull()) { mitkThrow() << "DataStorage not set"; } - DataNode::Pointer lastSelectedNode; m_LevelWindowProperty = nullptr; m_CurrentImage = nullptr; DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull() || node == removedNode) { continue; } // reset the "imageForLevelWindow" of each node m_LevelWindowMutex = true; node->SetBoolProperty("imageForLevelWindow", false); m_LevelWindowMutex = false; if (false == node->IsSelected()) { continue; } - bool validRenderingMode = HasLevelWindowRenderingMode(node); if (false == validRenderingMode) { continue; } m_LevelWindowProperty = dynamic_cast(node->GetProperty("levelwindow")); - m_DataNodesForLevelWindow.push_back(node); - lastSelectedNode = node; + m_DataNodesForLevelWindow.push_back(node); // nodes are used inside "SetLevelWindow" if the level window is changed } // this will set the "imageForLevelWindow" property and the 'm_CurrentImage' and call 'Modified()' this->SetLevelWindowProperty(m_LevelWindowProperty); if (m_LevelWindowProperty.IsNull()) { this->Modified(); } } void mitk::LevelWindowManager::RecalculateLevelWindowForSelectedComponent(const itk::EventObject &event) { DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull()) continue; bool isSelected = false; node->GetBoolProperty("selected", isSelected); if (isSelected) { LevelWindow selectedLevelWindow; node->GetLevelWindow(selectedLevelWindow); // node is an image node because of predicates auto *image = dynamic_cast(node->GetData()); int displayedComponent = 0; if (image && (node->GetIntProperty("Image.Displayed Component", displayedComponent))) { // we found a selected image with a displayed component // let's recalculate the levelwindow for this. selectedLevelWindow.SetAuto(image, true, true, static_cast(displayedComponent)); node->SetLevelWindow(selectedLevelWindow); } } LevelWindow levelWindow; node->GetLevelWindow(levelWindow); } this->Update(event); } void mitk::LevelWindowManager::Update(const itk::EventObject &) { if (m_LevelWindowMutex) // no mutex, should still help { return; } m_DataNodesForLevelWindow.clear(); if (m_AutoTopMost) { this->SetAutoTopMostImage(true); return; } if (m_SelectedImagesMode) { this->SetSelectedImages(true); return; } int maxVisibleLayer = itk::NumericTraits::min(); DataNode::Pointer topLevelNode = nullptr; std::vector nodesForLevelWindow; DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull()) { continue; } if (false == node->IsVisible(nullptr)) { continue; } bool validRenderingMode = HasLevelWindowRenderingMode(node); if (false == validRenderingMode) { continue; } bool prop = false; node->GetBoolProperty("imageForLevelWindow", prop); if (prop) { nodesForLevelWindow.push_back(node); continue; } int layer = -1; node->GetIntProperty("layer", layer); - if (layer > maxVisibleLayer) + if (layer <= maxVisibleLayer) { - // top level node is backup node, if no node with - // "imageForLevelWindow" property with value "true" is found - topLevelNode = node; - maxVisibleLayer = layer; + continue; } + + // top level node is backup node, if no node with + // "imageForLevelWindow" property with value "true" is found + topLevelNode = node; + maxVisibleLayer = layer; } int nodesForLevelWindowSize = nodesForLevelWindow.size(); if (nodesForLevelWindowSize > 2) { MITK_ERROR << "Error: not more than two visible nodes are expected to have the imageForLevelWindow property set at " "any point."; } if (nodesForLevelWindowSize > 0) { // 1 or 2 nodes for level window found for (const auto& node : nodesForLevelWindow) { LevelWindowProperty::Pointer newProp = dynamic_cast(node->GetProperty("levelwindow")); if (newProp != m_LevelWindowProperty) { this->SetLevelWindowProperty(newProp); return; } } } else if (topLevelNode) { // no nodes for level window found LevelWindowProperty::Pointer lvlProp = dynamic_cast(topLevelNode->GetProperty("levelwindow")); this->SetLevelWindowProperty(lvlProp); } else { // no nodes for level window found and no visible top level node found this->Modified(); } } void mitk::LevelWindowManager::UpdateSelected(const itk::EventObject &) { if (m_LevelWindowMutex) // no mutex, should still help { return; } m_DataNodesForLevelWindow.clear(); if (m_SelectedImagesMode) { this->SetSelectedImages(true); } } void mitk::LevelWindowManager::SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty) { if (levelWindowProperty.IsNull()) { return; } // find data node that belongs to the property DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll(); - mitk::DataNode::Pointer propNode = nullptr; + DataNode::Pointer propNode = nullptr; for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it.Value(); LevelWindowProperty::Pointer property = dynamic_cast(node->GetProperty("levelwindow")); if (property == levelWindowProperty) { propNode = node; } else { m_LevelWindowMutex = true; node->SetBoolProperty("imageForLevelWindow", false); m_LevelWindowMutex = false; } } if (propNode.IsNull()) { mitkThrow() << "No Image in the data storage that belongs to level-window property " << m_LevelWindowProperty; } if (m_IsPropertyModifiedTagSet) // remove listener for old property { m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag); m_IsPropertyModifiedTagSet = false; } m_LevelWindowProperty = levelWindowProperty; auto command = itk::ReceptorMemberCommand::New(); // register listener for new property command->SetCallbackFunction(this, &LevelWindowManager::OnPropertyModified); m_PropertyModifiedTag = m_LevelWindowProperty->AddObserver(itk::ModifiedEvent(), command); m_IsPropertyModifiedTagSet = true; m_CurrentImage = dynamic_cast(propNode->GetData()); m_LevelWindowMutex = true; propNode->SetBoolProperty("imageForLevelWindow", true); m_LevelWindowMutex = false; this->Modified(); } void mitk::LevelWindowManager::SetLevelWindow(const LevelWindow &levelWindow) { if (m_LevelWindowProperty.IsNull()) { return; } m_LevelWindowProperty->SetLevelWindow(levelWindow); for (const auto &dataNode : m_DataNodesForLevelWindow) { auto levelWindowProperty = dynamic_cast(dataNode->GetProperty("levelwindow")); if (nullptr == levelWindowProperty) { continue; } levelWindowProperty->SetLevelWindow(levelWindow); } this->Modified(); } -mitk::LevelWindowProperty::Pointer mitk::LevelWindowManager::GetLevelWindowProperty() +mitk::LevelWindowProperty::Pointer mitk::LevelWindowManager::GetLevelWindowProperty() const { return m_LevelWindowProperty; } -const mitk::LevelWindow &mitk::LevelWindowManager::GetLevelWindow() +const mitk::LevelWindow &mitk::LevelWindowManager::GetLevelWindow() const { if (m_LevelWindowProperty.IsNotNull()) { return m_LevelWindowProperty->GetLevelWindow(); } else { mitkThrow() << "No LevelWindow available!"; } } -bool mitk::LevelWindowManager::IsAutoTopMost() +bool mitk::LevelWindowManager::IsAutoTopMost() const { return m_AutoTopMost; } -bool mitk::LevelWindowManager::IsSelectedImages() +bool mitk::LevelWindowManager::IsSelectedImages() const { return m_SelectedImagesMode; } void mitk::LevelWindowManager::DataStorageAddedNode(const DataNode *) { // update observers with new data storage this->UpdateObservers(); // initialize LevelWindowManager to new image this->SetAutoTopMostImage(true); // check if everything is still ok if ((m_ObserverToVisibleProperty.size() != m_ObserverToLayerProperty.size()) || (m_ObserverToLayerProperty.size() != this->GetRelevantNodes()->size())) { mitkThrow() << "Wrong number of observers in Level Window Manager!"; } } void mitk::LevelWindowManager::DataStorageRemovedNode(const DataNode *removedNode) { // First: check if deleted node is part of relevant nodes. // If not, abort method because there is no need change anything. bool removedNodeIsRelevant = false; DataStorage::SetOfObjects::ConstPointer relevantNodes = GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = relevantNodes->Begin(); it != relevantNodes->End(); ++it) { if (it->Value() == removedNode) { removedNodeIsRelevant = true; } } if (false == removedNodeIsRelevant) { return; } // remember node which will be removed m_NodeMarkedToDelete = removedNode; // update observers this->UpdateObservers(); // search image that belongs to the property if (m_LevelWindowProperty.IsNull()) { this->SetAutoTopMostImage(true, removedNode); } else { auto property = NodePredicateProperty::New("levelwindow", m_LevelWindowProperty); DataNode *n = m_DataStorage->GetNode(property); if (n == nullptr || m_AutoTopMost) // if node was deleted, change our behavior to AutoTopMost, if AutoTopMost is // true change level window to topmost node { this->SetAutoTopMostImage(true, removedNode); } } // reset variable m_NodeMarkedToDelete = nullptr; // check if everything is still ok if ((m_ObserverToVisibleProperty.size() != m_ObserverToLayerProperty.size()) || (m_ObserverToLayerProperty.size() != (relevantNodes->size() - 1))) { mitkThrow() << "Wrong number of observers in Level Window Manager!"; } } void mitk::LevelWindowManager::OnPropertyModified(const itk::EventObject &) { this->Modified(); } -mitk::Image *mitk::LevelWindowManager::GetCurrentImage() +mitk::Image *mitk::LevelWindowManager::GetCurrentImage() const { return m_CurrentImage; } -int mitk::LevelWindowManager::GetNumberOfObservers() +int mitk::LevelWindowManager::GetNumberOfObservers() const { return m_ObserverToVisibleProperty.size(); } -mitk::DataStorage::SetOfObjects::ConstPointer mitk::LevelWindowManager::GetRelevantNodes() +mitk::DataStorage::SetOfObjects::ConstPointer mitk::LevelWindowManager::GetRelevantNodes() const { if (m_DataStorage.IsNull()) { return DataStorage::SetOfObjects::ConstPointer(DataStorage::SetOfObjects::New()); } auto notBinary = NodePredicateProperty::New("binary", BoolProperty::New(false)); auto hasLevelWindow = NodePredicateProperty::New("levelwindow", nullptr); auto isImage = NodePredicateDataType::New("Image"); auto isDImage = NodePredicateDataType::New("DiffusionImage"); auto isTImage = NodePredicateDataType::New("TensorImage"); auto isOdfImage = NodePredicateDataType::New("OdfImage"); auto isShImage = NodePredicateDataType::New("ShImage"); auto predicateTypes = NodePredicateOr::New(); predicateTypes->AddPredicate(isImage); predicateTypes->AddPredicate(isDImage); predicateTypes->AddPredicate(isTImage); predicateTypes->AddPredicate(isOdfImage); predicateTypes->AddPredicate(isShImage); NodePredicateAnd::Pointer predicate = NodePredicateAnd::New(); predicate->AddPredicate(notBinary); predicate->AddPredicate(hasLevelWindow); predicate->AddPredicate(predicateTypes); DataStorage::SetOfObjects::ConstPointer relevantNodes = m_DataStorage->GetSubset(predicate); return relevantNodes; } void mitk::LevelWindowManager::UpdateObservers() { this->ClearPropertyObserverMaps(); this->CreatePropertyObserverMaps(); } void mitk::LevelWindowManager::ClearPropertyObserverMaps() { for (auto iter = m_ObserverToVisibleProperty.begin(); iter != m_ObserverToVisibleProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToVisibleProperty.clear(); for (auto iter = m_ObserverToLayerProperty.begin(); iter != m_ObserverToLayerProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToLayerProperty.clear(); for (auto iter = m_ObserverToRenderingModeProperty.begin(); iter != m_ObserverToRenderingModeProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToRenderingModeProperty.clear(); for (auto iter = m_ObserverToDisplayedComponentProperty.begin(); iter != m_ObserverToDisplayedComponentProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToDisplayedComponentProperty.clear(); for (auto iter = m_ObserverToLevelWindowImageProperty.begin(); iter != m_ObserverToLevelWindowImageProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToLevelWindowImageProperty.clear(); for (auto iter = m_ObserverToSelectedProperty.begin(); iter != m_ObserverToSelectedProperty.end(); ++iter) { (*iter).second->RemoveObserver((*iter).first.first); (*iter).second = nullptr; } m_ObserverToSelectedProperty.clear(); } void mitk::LevelWindowManager::CreatePropertyObserverMaps() { if (m_DataStorage.IsNull()) { mitkThrow() << "DataStorage not set"; } // add observers for all relevant nodes DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes(); for (DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull() || node == m_NodeMarkedToDelete) { continue; } auto command = itk::ReceptorMemberCommand::New(); command->SetCallbackFunction(this, &LevelWindowManager::Update); unsigned long visIdx = node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command); m_ObserverToVisibleProperty[PropDataPair(visIdx, node)] = node->GetProperty("visible"); auto command2 = itk::ReceptorMemberCommand::New(); command2->SetCallbackFunction(this, &LevelWindowManager::Update); unsigned long layerIdx = node->GetProperty("layer")->AddObserver(itk::ModifiedEvent(), command2); m_ObserverToLayerProperty[PropDataPair(layerIdx, node)] = node->GetProperty("layer"); auto command3 = itk::ReceptorMemberCommand::New(); command3->SetCallbackFunction(this, &LevelWindowManager::Update); BaseProperty::Pointer imageRenderingMode = node->GetProperty("Image Rendering.Mode"); if (imageRenderingMode.IsNotNull()) { unsigned long rendIdx = imageRenderingMode->AddObserver(itk::ModifiedEvent(), command3); m_ObserverToRenderingModeProperty[PropDataPair(rendIdx, node)] = imageRenderingMode.GetPointer(); } auto command4 = itk::ReceptorMemberCommand::New(); command4->SetCallbackFunction(this, &LevelWindowManager::RecalculateLevelWindowForSelectedComponent); BaseProperty::Pointer displayedImageComponent = node->GetProperty("Image.Displayed Component"); if (displayedImageComponent.IsNotNull()) { unsigned long dispIdx = displayedImageComponent->AddObserver(itk::ModifiedEvent(), command4); m_ObserverToDisplayedComponentProperty[PropDataPair(dispIdx, node)] = displayedImageComponent.GetPointer(); } auto command5 = itk::ReceptorMemberCommand::New(); command5->SetCallbackFunction(this, &LevelWindowManager::Update); BaseProperty::Pointer imgForLvlWin = node->GetProperty("imageForLevelWindow"); if (imgForLvlWin.IsNull()) { node->SetBoolProperty("imageForLevelWindow", false); imgForLvlWin = node->GetProperty("imageForLevelWindow"); } unsigned long lvlWinIdx = imgForLvlWin->AddObserver(itk::ModifiedEvent(), command5); m_ObserverToLevelWindowImageProperty[PropDataPair(lvlWinIdx, node)] = node->GetProperty("imageForLevelWindow"); auto command6 = itk::ReceptorMemberCommand::New(); command6->SetCallbackFunction(this, &LevelWindowManager::UpdateSelected); BaseProperty::Pointer selectedDataNode = node->GetProperty("selected"); if (selectedDataNode.IsNull()) { node->SetBoolProperty("selected", false); selectedDataNode = node->GetProperty("selected"); } unsigned long selectedIdx = selectedDataNode->AddObserver(itk::ModifiedEvent(), command5); m_ObserverToSelectedProperty[PropDataPair(selectedIdx, node)] = node->GetProperty("selected"); } } -bool mitk::LevelWindowManager::HasLevelWindowRenderingMode(DataNode *dataNode) +bool mitk::LevelWindowManager::HasLevelWindowRenderingMode(DataNode *dataNode) const { RenderingModeProperty::Pointer mode = dynamic_cast(dataNode->GetProperty("Image Rendering.Mode")); if (mode.IsNotNull()) { int currMode = mode->GetRenderingMode(); if (currMode == RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR || currMode == RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR) { return true; } } return false; } diff --git a/Modules/Core/test/CMakeLists.txt b/Modules/Core/test/CMakeLists.txt index dc8d4ee9b4..7839cb73bd 100644 --- a/Modules/Core/test/CMakeLists.txt +++ b/Modules/Core/test/CMakeLists.txt @@ -1,181 +1,177 @@ # The core tests need relaxed compiler flags... # TODO fix core tests to compile without these additional no-error flags if(MSVC_VERSION) # disable deprecated warnings (they would lead to errors) mitkFunctionCheckCAndCXXCompilerFlags("/wd4996" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) else() mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-declarations" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() MITK_CREATE_MODULE_TESTS() if(TARGET ${TESTDRIVER}) mitk_use_modules(TARGET ${TESTDRIVER} PACKAGES ITK|IONRRD VTK|TestingRendering tinyxml2) mitkAddCustomModuleTest(mitkVolumeCalculatorTest_Png2D-bw mitkVolumeCalculatorTest ${MITK_DATA_DIR}/Png2D-bw.png ${MITK_DATA_DIR}/Pic2DplusT.nrrd ) mitkAddCustomModuleTest(mitkEventConfigTest_CreateObjectInDifferentWays mitkEventConfigTest ${MITK_SOURCE_DIR}/Modules/Core/test/resource/Interactions/StatemachineConfigTest.xml ) mitkAddCustomModuleTest(mitkDataStorageTest_US4DCyl mitkDataStorageTest ${MITK_DATA_DIR}/US4DCyl.nrrd ) mitkAddCustomModuleTest(mitkPointSetReaderTest mitkPointSetReaderTest ${MITK_DATA_DIR}/PointSetReaderTestData.mps ) mitkAddCustomModuleTest(mitkImageTest_4DImageData mitkImageTest ${MITK_DATA_DIR}/US4DCyl.nrrd ) mitkAddCustomModuleTest(mitkImageTest_2D+tImageData mitkImageTest ${MITK_DATA_DIR}/Pic2DplusT.nrrd ) mitkAddCustomModuleTest(mitkImageTest_3DImageData mitkImageTest ${MITK_DATA_DIR}/Pic3D.nrrd ) mitkAddCustomModuleTest(mitkImageEqualTest mitkImageEqualTest) mitkAddCustomModuleTest(mitkImageTest_brainImage mitkImageTest ${MITK_DATA_DIR}/brain.mhd ) - mitkAddCustomModuleTest(mitkLevelWindowManagerTest mitkLevelWindowManagerTest - ${MITK_DATA_DIR}/Pic3D.nrrd - ) - mitkAddCustomModuleTest(mitkMultiComponentImageDataComparisonFilterTest mitkMultiComponentImageDataComparisonFilterTest ${MITK_DATA_DIR}/NrrdWritingTestImage.jpg ) mitkAddCustomModuleTest(mitkImageToItkTest mitkImageToItkTest ${MITK_DATA_DIR}/Pic3D.nrrd ) mitkAddCustomModuleTest(mitkImageSliceSelectorTest mitkImageSliceSelectorTest ${MITK_DATA_DIR}/Pic2DplusT.nrrd ) mitkAddCustomModuleTest(mitkRotatedSlice4DTest mitkRotatedSlice4DTest ${MITK_DATA_DIR}/UltrasoundImages/4D_TEE_Data_MV.dcm ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_rgbaImage640x480 mitkImageVtkMapper2DTest ${MITK_DATA_DIR}/RenderingTestData/rgbaImage.png #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/rgbaImage640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_pic3d640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3d640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_pic3dColorBlue640x480 mitkImageVtkMapper2DColorTest #test for color property (=blue) Pic3D sagittal slice ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dColorBlue640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_pic3dLevelWindow640x480 mitkImageVtkMapper2DLevelWindowTest #test for levelwindow property (=blood) #Pic3D sagittal slice ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dLevelWindowBlood640x480REF.png #corresponding reference #screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_pic3dSwivel640x480 mitkImageVtkMapper2DSwivelTest #test for a randomly chosen Pic3D swivelled slice ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dSwivel640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkPointSetVtkMapper2D_openMeAlone640x480 mitkPointSetVtkMapper2DTest ${MITK_DATA_DIR}/RenderingTestData/openMeAlone.mps #input point set to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/openMeAlone640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkPointSetVtkMapper2D_Pic3DPointSetForPic3D640x480 mitkPointSetVtkMapper2DImageTest ${MITK_DATA_DIR}/Pic3D.nrrd ${MITK_DATA_DIR}/RenderingTestData/PointSetForPic3D.mps #input point set and image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Pic3DPointSetForPic3D640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkPointSetVtkMapper2D_openMeAloneGlyphType640x480 mitkPointSetVtkMapper2DGlyphTypeTest ${MITK_DATA_DIR}/RenderingTestData/openMeAlone.mps #input point set to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/openMeAloneGlyphType640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkPointSetVtkMapper2D_openMeAloneTransformed640x480 mitkPointSetVtkMapper2DTransformedPointsTest ${MITK_DATA_DIR}/RenderingTestData/openMeAlone.mps #input point set to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/openMeAloneTransformedPoints640x480REF.png #corresponding reference screenshot ) # Currently not working on windows because of a rendering timing issue # see bug 18083 for details if(NOT WIN32) mitkAddCustomModuleRenderingTest(mitkSurfaceDepthSortingTransparency_StanfordBunnySTL640x480 mitkSurfaceDepthSortingTest ${MITK_DATA_DIR}/RenderingTestData/Stanford_bunny.stl -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Stanford_bunnySTLDepthSorting640x480REF.png) endif() # BUG 18695 - tests deactivated, because win 32 bit continuous renders images slightly different. TODO! #Test reslice interpolation #note: nearest mode is already tested by swivel test #mitkAddCustomModuleRenderingTest(ResliceInterpolationIsLinear mitkImageVtkMapper2DResliceInterpolationPropertyTest # 1 #linear # ${MITK_DATA_DIR}/Pic3D.nrrd # -V # ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dRefLinear.png #corresponding reference screenshot LINEAR #) #mitkAddCustomModuleRenderingTest(ResliceInterpolationIsCubic mitkImageVtkMapper2DResliceInterpolationPropertyTest # 3 #cubic # ${MITK_DATA_DIR}/Pic3D.nrrd # -V # ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dRefCubic.png #corresponding reference screenshot CUBIC #) #End test reslice interpolation # Testing of the rendering of binary images #mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_binaryTestImage640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice # ${MITK_DATA_DIR}/RenderingTestData/binaryImage.nrrd #input image to load in data storage # -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/binaryImage640x480REF.png #corresponding reference screenshot #) #mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2D_binaryTestImageWithRef640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice # ${MITK_DATA_DIR}/Pic3D.nrrd ${MITK_DATA_DIR}/RenderingTestData/binaryImage.nrrd #input image to load in data storage # -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/binaryImageWithRef640x480REF.png #corresponding reference screenshot #) # End of binary image tests mitkAddCustomModuleRenderingTest(mitkSurfaceVtkMapper3DTest_TextureProperty mitkSurfaceVtkMapper3DTest ${MITK_DATA_DIR}/RenderingTestData/earth.jpg -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/texturedSphere640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2DTransferFunctionTest_Png2D-bw mitkImageVtkMapper2DTransferFunctionTest ${MITK_DATA_DIR}/Png2D-bw.png -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Png2D-bw-TransferFunctionRGBImage640x480REF.png #corresponding reference screenshot ) mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2DOpacityTransferFunctionTest_Png2D-bw mitkImageVtkMapper2DOpacityTransferFunctionTest ${MITK_DATA_DIR}/Png2D-bw.png -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Png2D-bw-OpacityTransferFunctionRGBImage640x480REF.png #corresponding reference screenshot ) ############################## DISABLED TESTS mitkAddCustomModuleRenderingTest(mitkImageVtkMapper2DLookupTableTest_Png2D-bw mitkImageVtkMapper2DLookupTableTest ${MITK_DATA_DIR}/Png2D-bw.png -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Png2D-bw-LookupTableRGBImage640x480REF.png #corresponding reference screenshot ) #mitkAddCustomModuleRenderingTest(mitkImageTest_color2DImage mitkImageTest # ${MITK_DATA_DIR}/NrrdWritingTestImage.jpg #) #mitkAddCustomModuleRenderingTest(mitkNodeDependentPointSetInteractorTest mitkNodeDependentPointSetInteractorTest # ${MITK_DATA_DIR}/Pic3D.pic.gz ${MITK_DATA_DIR}/BallBinary30x30x30.pic.gz #) mitkAddCustomModuleRenderingTest(mitkPlaneGeometryDataMapper2DTest mitkPlaneGeometryDataMapper2DTest ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/PlaneGeometryMapper640x480REF.png #corresponding reference screenshot ) endif() # TARGET ${TESTDRIVER} diff --git a/Modules/Core/test/files.cmake b/Modules/Core/test/files.cmake index 201b7c43ef..9aa105bf67 100644 --- a/Modules/Core/test/files.cmake +++ b/Modules/Core/test/files.cmake @@ -1,198 +1,198 @@ # tests with no extra command line parameter set(MODULE_TESTS # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code. # # Example: #mitkMyTest #this test is commented out because of bug 12345 # # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and # mark it as critical. ################## DISABLED TESTS ################################################# #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529 #mitkRegistrationBaseTest.cpp #tested class mitkRegistrationBase doesn't exist any more #mitkSegmentationInterpolationTest.cpp #file doesn't exist! #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist! #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more #mitkTestUtilSharedLibrary.cpp #Linker problem with this test... #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details. ################# RUNNING TESTS ################################################### mitkAccessByItkTest.cpp mitkCoreObjectFactoryTest.cpp mitkDataNodeTest.cpp mitkMaterialTest.cpp mitkActionTest.cpp mitkDispatcherTest.cpp mitkEnumerationPropertyTest.cpp mitkFileReaderRegistryTest.cpp #mitkFileWriterRegistryTest.cpp mitkFloatToStringTest.cpp mitkGenericPropertyTest.cpp mitkGeometry3DTest.cpp mitkGeometry3DEqualTest.cpp mitkGeometryDataIOTest.cpp mitkGeometryDataToSurfaceFilterTest.cpp mitkImageCastTest.cpp mitkImageDataItemTest.cpp mitkImageGeneratorTest.cpp mitkIOUtilTest.cpp mitkBaseDataTest.cpp mitkImportItkImageTest.cpp mitkGrabItkImageMemoryTest.cpp mitkInstantiateAccessFunctionTest.cpp mitkLevelWindowTest.cpp mitkMessageTest.cpp mitkPixelTypeTest.cpp mitkPlaneGeometryTest.cpp mitkPointSetTest.cpp mitkPointSetEqualTest.cpp mitkPointSetFileIOTest.cpp mitkPointSetOnEmptyTest.cpp mitkPointSetLocaleTest.cpp mitkPointSetWriterTest.cpp mitkPointSetPointOperationsTest.cpp mitkProgressBarTest.cpp mitkPropertyTest.cpp mitkPropertyListTest.cpp mitkPropertyPersistenceTest.cpp mitkPropertyPersistenceInfoTest.cpp mitkPropertyRelationRuleBaseTest.cpp mitkPropertyRelationsTest.cpp mitkSlicedGeometry3DTest.cpp mitkSliceNavigationControllerTest.cpp mitkSurfaceTest.cpp mitkSurfaceEqualTest.cpp mitkSurfaceToSurfaceFilterTest.cpp mitkTimeGeometryTest.cpp mitkProportionalTimeGeometryTest.cpp mitkUndoControllerTest.cpp mitkVtkWidgetRenderingTest.cpp mitkVerboseLimitedLinearUndoTest.cpp mitkWeakPointerTest.cpp mitkTransferFunctionTest.cpp mitkStepperTest.cpp mitkRenderingManagerTest.cpp mitkCompositePixelValueToStringTest.cpp vtkMitkThickSlicesFilterTest.cpp mitkNodePredicateSourceTest.cpp mitkNodePredicateDataPropertyTest.cpp mitkNodePredicateFunctionTest.cpp mitkVectorTest.cpp mitkClippedSurfaceBoundsCalculatorTest.cpp mitkExceptionTest.cpp mitkExtractSliceFilterTest.cpp mitkLogTest.cpp mitkImageDimensionConverterTest.cpp mitkLoggingAdapterTest.cpp mitkUIDGeneratorTest.cpp mitkPlanePositionManagerTest.cpp mitkAffineTransformBaseTest.cpp mitkPropertyAliasesTest.cpp mitkPropertyDescriptionsTest.cpp mitkPropertyExtensionsTest.cpp mitkPropertyFiltersTest.cpp mitkPropertyKeyPathTest.cpp mitkTinyXMLTest.cpp mitkRawImageFileReaderTest.cpp mitkInteractionEventTest.cpp mitkLookupTableTest.cpp mitkSTLFileReaderTest.cpp mitkPointTypeConversionTest.cpp mitkVectorTypeConversionTest.cpp mitkMatrixTypeConversionTest.cpp mitkArrayTypeConversionTest.cpp mitkSurfaceToImageFilterTest.cpp mitkBaseGeometryTest.cpp mitkImageToSurfaceFilterTest.cpp mitkEqualTest.cpp mitkLineTest.cpp mitkArbitraryTimeGeometryTest.cpp mitkItkImageIOTest.cpp - mitkLevelWindowManagerCppUnitTest.cpp + mitkLevelWindowManagerTest.cpp mitkVectorPropertyTest.cpp mitkTemporoSpatialStringPropertyTest.cpp mitkPropertyNameHelperTest.cpp mitkNodePredicateGeometryTest.cpp mitkNodePredicateSubGeometryTest.cpp mitkPreferenceListReaderOptionsFunctorTest.cpp mitkGenericIDRelationRuleTest.cpp mitkSourceImageRelationRuleTest.cpp mitkTemporalJoinImagesFilterTest.cpp ) set(MODULE_RENDERING_TESTS mitkPointSetDataInteractorTest.cpp mitkSurfaceVtkMapper2DTest.cpp mitkSurfaceVtkMapper2D3DTest.cpp ) # test with image filename as an extra command line parameter set(MODULE_IMAGE_TESTS mitkImageTimeSelectorTest.cpp #only runs on images mitkImageAccessorTest.cpp #only runs on images ) set(MODULE_SURFACE_TESTS mitkSurfaceVtkWriterTest.cpp #only runs on surfaces ) # list of images for which the tests are run set(MODULE_TESTIMAGE US4DCyl.nrrd Pic3D.nrrd Pic2DplusT.nrrd BallBinary30x30x30.nrrd Png2D-bw.png ) set(MODULE_TESTSURFACE binary.stl ball.stl ) set(MODULE_CUSTOM_TESTS mitkDataStorageTest.cpp mitkDataNodeTest.cpp mitkEventConfigTest.cpp mitkPointSetLocaleTest.cpp mitkImageTest.cpp mitkImageVtkMapper2DTest.cpp mitkImageVtkMapper2DLevelWindowTest.cpp mitkImageVtkMapper2DOpacityTest.cpp mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp mitkImageVtkMapper2DColorTest.cpp mitkImageVtkMapper2DSwivelTest.cpp mitkImageVtkMapper2DTransferFunctionTest.cpp mitkImageVtkMapper2DOpacityTransferFunctionTest.cpp mitkImageVtkMapper2DLookupTableTest.cpp mitkSurfaceVtkMapper3DTest.cpp mitkVolumeCalculatorTest.cpp mitkLevelWindowManagerTest.cpp mitkPointSetVtkMapper2DTest.cpp mitkPointSetVtkMapper2DImageTest.cpp mitkPointSetVtkMapper2DGlyphTypeTest.cpp mitkPointSetVtkMapper2DTransformedPointsTest.cpp mitkVTKRenderWindowSizeTest.cpp mitkMultiComponentImageDataComparisonFilterTest.cpp mitkImageToItkTest.cpp mitkImageSliceSelectorTest.cpp mitkPointSetReaderTest.cpp mitkImageEqualTest.cpp mitkRotatedSlice4DTest.cpp mitkPlaneGeometryDataMapper2DTest.cpp ) # Currently not working on windows because of a rendering timing issue # see bug 18083 for details if(NOT WIN32) set(MODULE_CUSTOM_TESTS ${MODULE_CUSTOM_TESTS} mitkSurfaceDepthSortingTest.cpp) endif() set(RESOURCE_FILES Interactions/AddAndRemovePoints.xml Interactions/globalConfig.xml Interactions/StatemachineTest.xml Interactions/StatemachineConfigTest.xml ) diff --git a/Modules/Core/test/mitkLevelWindowManagerCppUnitTest.cpp b/Modules/Core/test/mitkLevelWindowManagerCppUnitTest.cpp deleted file mode 100644 index ece270c293..0000000000 --- a/Modules/Core/test/mitkLevelWindowManagerCppUnitTest.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/*============================================================================ - -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. - -============================================================================*/ - -#include "mitkTestingMacros.h" -#include - -#include "mitkLevelWindowManager.h" -#include "mitkStandaloneDataStorage.h" -#include -#include -#include -#include -#include - -class mitkLevelWindowManagerCppUnitTestSuite : public mitk::TestFixture -{ - CPPUNIT_TEST_SUITE(mitkLevelWindowManagerCppUnitTestSuite); - MITK_TEST(TestMultiComponentRescaling); - CPPUNIT_TEST_SUITE_END(); - -private: - mitk::Image::Pointer m_mitkMultiComponentImage; - mitk::Image::Pointer m_mitkImageComponent1; - mitk::Image::Pointer m_mitkImageComponent2; - -public: - void setUp() override - { - typedef itk::Image ImageType; - typedef itk::ImageRegionIterator ImageIteratorType; - typedef itk::ImageDuplicator DuplicatorType; - typedef itk::ComposeImageFilter CompositeFilterType; - - // generate two images with one component - ImageType::Pointer imageComponent1 = itk::Image::New(); - ImageType::IndexType start; - start.Fill(0); - ImageType::SizeType size; - size.Fill(5); - ImageType::RegionType region; - region.SetSize(size); - region.SetIndex(start); - imageComponent1->SetRegions(region); - imageComponent1->Allocate(); - - DuplicatorType::Pointer duplicator = DuplicatorType::New(); - duplicator->SetInputImage(imageComponent1); - duplicator->Update(); - ImageType::Pointer imageComponent2 = duplicator->GetOutput(); - - // give them differing data - ImageIteratorType iterator1(imageComponent1, imageComponent1->GetLargestPossibleRegion()); - iterator1.GoToBegin(); - int i = 0; - while (!iterator1.IsAtEnd()) - { - iterator1.Set((double)i); - ++iterator1; - ++i; - } - - ImageIteratorType iterator2(imageComponent2, imageComponent2->GetLargestPossibleRegion()); - iterator2.GoToBegin(); - i = 2000; - while (!iterator2.IsAtEnd()) - { - iterator2.Set((double)i); - ++iterator2; - ++i; - } - - // copy into single VectorImage - CompositeFilterType::Pointer compositeFilter = CompositeFilterType::New(); - compositeFilter->SetInput(0, imageComponent1); - compositeFilter->SetInput(1, imageComponent2); - compositeFilter->Update(); - itk::VectorImage::Pointer multiComponentImage = compositeFilter->GetOutput(); - - // cast images to mitk - mitk::CastToMitkImage(multiComponentImage, m_mitkMultiComponentImage); - mitk::CastToMitkImage(imageComponent1, m_mitkImageComponent1); - mitk::CastToMitkImage(imageComponent2, m_mitkImageComponent2); - } - - static mitk::LevelWindow getLevelWindowForImage(mitk::Image *image, unsigned component) - { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - - try - { - manager->SetDataStorage(ds); - } - catch (std::exception &e) - { - MITK_ERROR << "Exception: " << e.what(); - } - - mitk::DataNode::Pointer node = mitk::DataNode::New(); - node->SetData(image); - ds->Add(node); - - node->SetBoolProperty("selected", true); - node->SetIntProperty("Image.Displayed Component", component); - - mitk::LevelWindow levelWindow; - node->GetLevelWindow(levelWindow); - return levelWindow; // node is an image node because of predicates - } - - void TestMultiComponentRescaling() - { - // compute level windows for the three images - mitk::LevelWindow imageComponent1LevelWindow = getLevelWindowForImage(m_mitkImageComponent1, 0); - mitk::LevelWindow imageComponent2LevelWindow = getLevelWindowForImage(m_mitkImageComponent2, 0); - // calculate level window for second component in multi-component image - mitk::LevelWindow multiComponentImageLevelWindow = getLevelWindowForImage(m_mitkMultiComponentImage, 1); - - // compare level window boundaries. the multicomponent image level window - // should match the second image, since the second component was selected - CPPUNIT_ASSERT_EQUAL_MESSAGE("default lower bounds equal", - imageComponent2LevelWindow.GetDefaultLowerBound(), - multiComponentImageLevelWindow.GetDefaultLowerBound()); - - CPPUNIT_ASSERT_EQUAL_MESSAGE("default upper bounds equal", - imageComponent2LevelWindow.GetDefaultUpperBound(), - multiComponentImageLevelWindow.GetDefaultUpperBound()); - - CPPUNIT_ASSERT_EQUAL_MESSAGE( - "range equal", imageComponent2LevelWindow.GetRange(), multiComponentImageLevelWindow.GetRange()); - - CPPUNIT_ASSERT(imageComponent1LevelWindow.GetDefaultLowerBound() != - multiComponentImageLevelWindow.GetDefaultLowerBound()); - - CPPUNIT_ASSERT(imageComponent1LevelWindow.GetDefaultUpperBound() != - multiComponentImageLevelWindow.GetDefaultUpperBound()); - } -}; - -MITK_TEST_SUITE_REGISTRATION(mitkLevelWindowManagerCppUnit) diff --git a/Modules/Core/test/mitkLevelWindowManagerTest.cpp b/Modules/Core/test/mitkLevelWindowManagerTest.cpp index 1d7de8c01e..43cddaee66 100644 --- a/Modules/Core/test/mitkLevelWindowManagerTest.cpp +++ b/Modules/Core/test/mitkLevelWindowManagerTest.cpp @@ -1,621 +1,439 @@ /*============================================================================ 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. ============================================================================*/ -#include "itkMersenneTwisterRandomVariateGenerator.h" -#include "mitkLevelWindowManager.h" -#include "mitkRenderingModeProperty.h" -#include "mitkStandaloneDataStorage.h" +#include +#include + +#include +#include +#include +#include + #include #include #include #include -#include -#include #include -#include -class mitkLevelWindowManagerTestClass +class mitkLevelWindowManagerTestSuite : public mitk::TestFixture { -public: - static void TestInstantiation() - { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - MITK_TEST_CONDITION_REQUIRED(manager.IsNotNull(), "Testing mitk::LevelWindowManager::New()"); - } + CPPUNIT_TEST_SUITE(mitkLevelWindowManagerTestSuite); + MITK_TEST(TestModes); + MITK_TEST(TestSetLevelWindowProperty); + MITK_TEST(TestVisibilityPropertyChanged); + MITK_TEST(TestLayerPropertyChanged); + MITK_TEST(TestImageRenderingModePropertyChanged); + MITK_TEST(TestImageForLevelWindowPropertyChanged); + MITK_TEST(TestSelectedPropertyChanged); + MITK_TEST(TestRemoveDataNodes); + MITK_TEST(TestCombinedPropertiesChanged); - static void TestSetGetDataStorage() - { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - MITK_TEST_OUTPUT(<< "Creating DataStorage: "); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); + CPPUNIT_TEST_SUITE_END(); - bool success = true; - try - { - manager->SetDataStorage(ds); - } - catch (std::exception &e) - { - success = false; - MITK_ERROR << "Exception: " << e.what(); - } - MITK_TEST_CONDITION_REQUIRED(success, "Testing mitk::LevelWindowManager SetDataStorage() "); - MITK_TEST_CONDITION_REQUIRED(ds == manager->GetDataStorage(), "Testing mitk::LevelWindowManager GetDataStorage "); - } +private: - static void TestMethodsWithInvalidParameters() - { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - bool success = false; - mitk::LevelWindowProperty::Pointer levelWindowProperty = mitk::LevelWindowProperty::New(); - try - { - manager->SetLevelWindowProperty(levelWindowProperty); - } - catch (const mitk::Exception &) - { - success = true; - } - MITK_TEST_CONDITION(success, "Testing mitk::LevelWindowManager SetLevelWindowProperty with invalid parameter"); - } + mitk::LevelWindowManager::Pointer m_LevelWindowManager; + mitk::StandaloneDataStorage::Pointer m_DataManager; - static void TestOtherMethods() - { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - MITK_TEST_CONDITION(manager->IsAutoTopMost(), "Testing mitk::LevelWindowManager isAutoTopMost"); - - // It is not clear what the following code is supposed to test. The expression in - // the catch(...) block does have no effect, so success is always true. - // Related bugs are 13894 and 13889 - /* - bool success = true; - try + std::string m_ImagePath1; + std::string m_ImagePath2; + std::string m_ImagePath3; + + mitk::DataNode::Pointer m_DataNode1; + mitk::DataNode::Pointer m_DataNode2; + mitk::DataNode::Pointer m_DataNode3; + + mitk::Image::Pointer m_mitkMultiComponentImage; + mitk::Image::Pointer m_mitkImageComponent1; + mitk::Image::Pointer m_mitkImageComponent2; + + bool AssertImageForLevelWindowProperty(bool assert1, bool assert2, bool assert3) { - mitk::LevelWindow levelWindow = manager->GetLevelWindow(); - manager->SetLevelWindow(levelWindow); + bool imageForLevelWindowProperty1, imageForLevelWindowProperty2, imageForLevelWindowProperty3; + + m_DataNode1->GetBoolProperty("imageForLevelWindow", imageForLevelWindowProperty1); + m_DataNode2->GetBoolProperty("imageForLevelWindow", imageForLevelWindowProperty2); + m_DataNode3->GetBoolProperty("imageForLevelWindow", imageForLevelWindowProperty3); + + return (assert1 == imageForLevelWindowProperty1) && + (assert2 == imageForLevelWindowProperty2) && + (assert3 == imageForLevelWindowProperty3); } - catch (...) + + bool AssertLevelWindowProperty(bool assert1, bool assert2, bool assert3) { - success == false; + auto levelWindowProperty1 = + dynamic_cast(m_DataNode1->GetProperty("levelwindow")); + auto levelWindowProperty2 = + dynamic_cast(m_DataNode2->GetProperty("levelwindow")); + auto levelWindowProperty3 = + dynamic_cast(m_DataNode3->GetProperty("levelwindow")); + + // Check if the active level window property of the manager is equal to any of the level window properties of the nodes + auto managerLevelWindowProperty = m_LevelWindowManager->GetLevelWindowProperty(); + + return (assert1 == (managerLevelWindowProperty == levelWindowProperty1)) && + (assert2 == (managerLevelWindowProperty == levelWindowProperty2)) && + (assert3 == (managerLevelWindowProperty == levelWindowProperty3)); } - MITK_TEST_CONDITION(success,"Testing mitk::LevelWindowManager GetLevelWindow() and SetLevelWindow()"); - */ - manager->SetAutoTopMostImage(true); - MITK_TEST_CONDITION(manager->IsAutoTopMost(), "Testing mitk::LevelWindowManager isAutoTopMost()"); - } +public: - static void TestRemoveObserver(std::string testImageFile) + void setUp() override { - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - // add multiple objects to the data storage => multiple observers should be created - mitk::Image::Pointer image1 = mitk::IOUtil::Load(testImageFile); - mitk::DataNode::Pointer node1 = mitk::DataNode::New(); - node1->SetData(image1); - mitk::Image::Pointer image2 = mitk::IOUtil::Load(testImageFile); - mitk::DataNode::Pointer node2 = mitk::DataNode::New(); - node2->SetData(image2); - ds->Add(node1); - ds->Add(node2); - - MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 2, "Test if nodes have been added"); - MITK_TEST_CONDITION_REQUIRED( - static_cast(manager->GetRelevantNodes()->size()) == manager->GetNumberOfObservers(), - "Test if number of nodes is similar to number of observers"); - - mitk::Image::Pointer image3 = mitk::IOUtil::Load(testImageFile); - mitk::DataNode::Pointer node3 = mitk::DataNode::New(); - node3->SetData(image3); - ds->Add(node3); - MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 3, "Test if another node have been added"); - MITK_TEST_CONDITION_REQUIRED( - static_cast(manager->GetRelevantNodes()->size()) == manager->GetNumberOfObservers(), - "Test if number of nodes is similar to number of observers"); - - ds->Remove(node1); - MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 2, "Deleted node 1 (test GetRelevantNodes())"); - MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 2, "Deleted node 1 (test GetNumberOfObservers())"); - - ds->Remove(node2); - MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 1, "Deleted node 2 (test GetRelevantNodes())"); - MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 1, "Deleted node 2 (test GetNumberOfObservers())"); - - ds->Remove(node3); - MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 0, "Deleted node 3 (test GetRelevantNodes())"); - MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 0, "Deleted node 3 (test GetNumberOfObservers())"); + m_LevelWindowManager = mitk::LevelWindowManager::New(); + m_DataManager = mitk::StandaloneDataStorage::New(); + + CPPUNIT_ASSERT_NO_THROW_MESSAGE("DataStorage could not be set for the new level window manager", m_LevelWindowManager->SetDataStorage(m_DataManager)); + CPPUNIT_ASSERT_MESSAGE("DataStorage could not be retrieved from the new level window manager", m_DataManager == m_LevelWindowManager->GetDataStorage()); + + m_ImagePath1 = GetTestDataFilePath("Pic3D.nrrd"); + m_ImagePath2 = GetTestDataFilePath("UltrasoundImages/4D_TEE_Data_MV.dcm"); + m_ImagePath3 = GetTestDataFilePath("RenderingTestData/defaultWatermark.png"); + + // add multiple objects to the data storage => property observers will be created + m_DataNode1 = mitk::IOUtil::Load(m_ImagePath1, *m_DataManager)->GetElement(0); + m_DataNode2 = mitk::IOUtil::Load(m_ImagePath2, *m_DataManager)->GetElement(0); + CPPUNIT_ASSERT_MESSAGE("Not two relevant nodes found in the data storage", + m_LevelWindowManager->GetRelevantNodes()->size() == 2); + CPPUNIT_ASSERT_MESSAGE("Not two observers created for the relevant nodes", + m_LevelWindowManager->GetNumberOfObservers() == 2); + + m_DataNode1->SetIntProperty("layer", 1); + m_DataNode2->SetIntProperty("layer", 2); + + bool isImageForLevelWindow1, isImageForLevelWindow2; + m_DataNode1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); + m_DataNode2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); + CPPUNIT_ASSERT_MESSAGE("Initial \"imageForLevelWindow\" property not exclusively set for node 2", + !isImageForLevelWindow1 && isImageForLevelWindow2); + + m_DataNode3 = mitk::IOUtil::Load(m_ImagePath3, *m_DataManager)->GetElement(0); + CPPUNIT_ASSERT_MESSAGE("Not three relevant nodes found in the data storage", + m_LevelWindowManager->GetRelevantNodes()->size() == 3); + CPPUNIT_ASSERT_MESSAGE("Not three observers created for the relevant nodes", + m_LevelWindowManager->GetNumberOfObservers() == 3); + + m_DataNode3->SetIntProperty("layer", 3); + AssertImageForLevelWindowProperty(false, false, true); } - static bool VerifyRenderingModes() + void tearDown() override {} + + void TestModes() { - bool ok = (mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR == 1) && - (mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR == 2) && - (mitk::RenderingModeProperty::LOOKUPTABLE_COLOR == 3) && - (mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR == 4); + CPPUNIT_ASSERT_MESSAGE("AutoTopMost mode is not enabled per default", m_LevelWindowManager->IsAutoTopMost()); + CPPUNIT_ASSERT_MESSAGE("SelectedImagesMode mode is not disabled per default", !m_LevelWindowManager->IsSelectedImages()); - return ok; - } + m_LevelWindowManager->SetSelectedImages(true); + CPPUNIT_ASSERT_MESSAGE("AutoTopMost mode was not disabled on mode switch", !m_LevelWindowManager->IsAutoTopMost()); + CPPUNIT_ASSERT_MESSAGE("SelectedImagesMode mode was not enabled on mode switch", m_LevelWindowManager->IsSelectedImages()); - static void TestLevelWindowSliderVisibility(std::string testImageFile) - { - bool renderingModesValid = mitkLevelWindowManagerTestClass::VerifyRenderingModes(); - if (!renderingModesValid) - { - MITK_ERROR << "Exception: Image Rendering.Mode property value types inconsistent."; - } + m_LevelWindowManager->SetSelectedImages(false); + CPPUNIT_ASSERT_MESSAGE("AutoTopMost mode was not disabled on mode switch", !m_LevelWindowManager->IsAutoTopMost()); + CPPUNIT_ASSERT_MESSAGE("SelectedImagesMode mode was not disabled on mode switch", !m_LevelWindowManager->IsSelectedImages()); - mitk::LevelWindowManager::Pointer manager; - manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - // add multiple objects to the data storage => multiple observers should be created - mitk::Image::Pointer image1 = mitk::IOUtil::Load(testImageFile); - mitk::DataNode::Pointer node1 = mitk::DataNode::New(); - node1->SetData(image1); - ds->Add(node1); - - mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - std::vector nodeVec; - // nodeVec.resize( 3 ); - nodeVec.push_back(node1); - nodeVec.push_back(node2); - nodeVec.push_back(node3); - - typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; - RandomGeneratorType::Pointer rnd = RandomGeneratorType::New(); - rnd->Initialize(); - - for (unsigned int i = 0; i < 8; ++i) - { - unsigned int parity = i; - - for (unsigned int img = 0; img < 3; ++img) - { - if (parity & 1) - { - int mode = rnd->GetIntegerVariate() % 3; - nodeVec[img]->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mode)); - } - else - { - int mode = rnd->GetIntegerVariate() % 2; - nodeVec[img]->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(3 + mode)); - } - parity >>= 1; - } - - MITK_TEST_CONDITION( - renderingModesValid && ((!manager->GetLevelWindowProperty() && !i) || (manager->GetLevelWindowProperty() && i)), - "Testing level window property member according to rendering mode"); - } + m_LevelWindowManager->SetSelectedImages(true); // to enable "SelectedImagesMode" + m_LevelWindowManager->SetAutoTopMostImage(true); + CPPUNIT_ASSERT_MESSAGE("AutoTopMost mode was not enabled on mode switch", m_LevelWindowManager->IsAutoTopMost()); + CPPUNIT_ASSERT_MESSAGE("SelectedImagesMode mode was not disabled on mode switch", !m_LevelWindowManager->IsSelectedImages()); } - static void TestSetLevelWindowProperty(std::string testImageFile) + void TestSetLevelWindowProperty() { - mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - // add multiple objects to the data storage => multiple observers should be created - mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - - node3->SetIntProperty("layer", 1); - node2->SetIntProperty("layer", 2); - node1->SetIntProperty("layer", 3); - - manager->SetAutoTopMostImage(true); - - bool isImageForLevelWindow1, isImageForLevelWindow2, isImageForLevelWindow3; - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); - - MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 1."); - - manager->SetAutoTopMostImage(false); - - mitk::LevelWindowProperty::Pointer prop = - dynamic_cast(node2->GetProperty("levelwindow")); - manager->SetLevelWindowProperty(prop); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); - - MITK_TEST_CONDITION(!isImageForLevelWindow1 && isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 2."); - - prop = dynamic_cast(node3->GetProperty("levelwindow")); - manager->SetLevelWindowProperty(prop); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); - - MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 3."); - - prop = dynamic_cast(node1->GetProperty("levelwindow")); - manager->SetLevelWindowProperty(prop); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); - - MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 3."); + m_LevelWindowManager->SetAutoTopMostImage(false); + + // Setting the level window property of the manager + // will make the corresponding node be the "imageForLevelWindow" node. + auto levelWindowProperty = dynamic_cast(m_DataNode1->GetProperty("levelwindow")); + m_LevelWindowManager->SetLevelWindowProperty(levelWindowProperty); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + levelWindowProperty = dynamic_cast(m_DataNode2->GetProperty("levelwindow")); + m_LevelWindowManager->SetLevelWindowProperty(levelWindowProperty); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + levelWindowProperty = dynamic_cast(m_DataNode3->GetProperty("levelwindow")); + m_LevelWindowManager->SetLevelWindowProperty(levelWindowProperty); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + + levelWindowProperty = mitk::LevelWindowProperty::New(); + //CPPUNIT_ASSERT_THROW_MESSAGE("Expected exception for an invalid level window property was not thrown", + //m_LevelWindowManager->SetLevelWindowProperty(levelWindowProperty), mitk::Exception); } - static void TestImageForLevelWindowOnVisibilityChange(std::string testImageFile) + void TestVisibilityPropertyChanged() { - mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - // add multiple objects to the data storage => multiple observers should be created - mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - - node3->SetIntProperty("layer", 1); - node2->SetIntProperty("layer", 2); - node1->SetIntProperty("layer", 3); + // Hiding a node will make the "next" node be the "imageForLevelWindow" node, if + // the hidden node was the "imageForLevelWindow" node before. "Next" is dependent on the node layer. + m_DataNode3->SetVisibility(false); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode2->SetVisibility(false); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode1->SetVisibility(false); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is not null", !m_LevelWindowManager->GetLevelWindowProperty()); + + m_DataNode3->SetVisibility(true); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + } - manager->SetAutoTopMostImage(false); + void TestLayerPropertyChanged() + { + m_DataNode3->SetIntProperty("layer", itk::NumericTraits::min()); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode2->SetIntProperty("layer", itk::NumericTraits::min()); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode1->SetIntProperty("layer", itk::NumericTraits::min()); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is not null", !m_LevelWindowManager->GetLevelWindowProperty()); + + m_DataNode3->SetIntProperty("layer", 1); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + } - bool isImageForLevelWindow1, isImageForLevelWindow2, isImageForLevelWindow3; - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); + void TestImageRenderingModePropertyChanged() + { + // checking the default rendering mode + auto renderingMode = dynamic_cast(m_DataNode3->GetProperty("Image Rendering.Mode")); + CPPUNIT_ASSERT_MESSAGE("Initial \"Image Rendering.Mode\" property not set to \"RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR\"", + mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR == renderingMode->GetRenderingMode()); + + // Changing the "Image Rendering.Mode" of a node to either "LOOKUPTABLE_COLOR" or + // "COLORTRANSFERFUNCTION_COLOR" will ignore this node for the level window + m_DataNode3->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode2->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR)); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode1->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is not null", !m_LevelWindowManager->GetLevelWindowProperty()); + + m_DataNode3->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR)); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + } - MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing initial imageForLevelWindow setting."); + void TestImageForLevelWindowPropertyChanged() + { + m_LevelWindowManager->SetAutoTopMostImage(false); - node1->SetVisibility(false); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); + m_DataNode1->SetBoolProperty("imageForLevelWindow", true); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); - MITK_TEST_CONDITION(!isImageForLevelWindow1 && isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 2."); + m_DataNode2->SetBoolProperty("imageForLevelWindow", true); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); - node2->SetVisibility(false); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); + m_DataNode3->SetBoolProperty("imageForLevelWindow", true); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); - MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 3."); + // The top level node will alsways be used as a fall back node + // if no specific mode is selected. + m_DataNode3->SetBoolProperty("imageForLevelWindow", false); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + } - node3->SetVisibility(false); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); + void TestSelectedPropertyChanged() + { + // Selecting a node will make this node be the "imageForLevelWindow" node, if + // the "SelectedImagesMode" is enabled (disabled per default). + m_DataNode1->SetSelected(true); // selection mode not enabled - node3 stays the "imageForLevelWindow" node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + + // This will immediately check for the selected node (node 1). + m_LevelWindowManager->SetSelectedImages(true); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + // Second node will be selected (node 1 and node 2 selected). + // It is not specified which data node will be used for the "imageForLevelWindow" / "levelwindow" property, + // since the data storage access to the nodes is non-deterministic. + // At least check for any valid level window property. + m_DataNode2->SetSelected(true); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is null", m_LevelWindowManager->GetLevelWindowProperty()); + + // Third node will be selected (node 1, node 2 and node 3 selected) + // It is not specified which data node will be used for the "imageForLevelWindow" / "levelwindow" property, + // since the data storage access to the nodes is non-deterministic. + // At least check for any valid level window property. + m_DataNode3->SetSelected(true); + auto usedLevelWindowProperty = m_LevelWindowManager->GetLevelWindowProperty(); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is null", usedLevelWindowProperty); + + // All three nodes are selected: Check if only one node has the "imageForLevelWindow" property set and this node's + // "levelwindow" property is used by the level window manager. + auto levelWindowProperty1 = dynamic_cast(m_DataNode1->GetProperty("imageForLevelWindow")); + if (usedLevelWindowProperty == levelWindowProperty1) + { + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + } - MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 3."); + auto levelWindowProperty2 = dynamic_cast(m_DataNode2->GetProperty("imageForLevelWindow")); + if (usedLevelWindowProperty == levelWindowProperty2) + { + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + } - node1->SetVisibility(true); - node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); - node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); - node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3); + auto levelWindowProperty3 = dynamic_cast(m_DataNode3->GetProperty("imageForLevelWindow")); + if (usedLevelWindowProperty == levelWindowProperty3) + { + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + } - MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3, - "Testing exclusive imageForLevelWindow property for node 3."); + m_DataNode1->SetSelected(false); + m_DataNode2->SetSelected(false); + m_DataNode3->SetSelected(false); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is not null", !m_LevelWindowManager->GetLevelWindowProperty()); } - static void TestImageForLevelWindowOnRandomPropertyChange(std::string testImageFile) + void TestCombinedPropertiesChanged() { - typedef std::vector BoolVecType; - typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; - - // initialize the data storage - mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - - node3->SetIntProperty("layer", 1); - node2->SetIntProperty("layer", 2); - node1->SetIntProperty("layer", 3); - - // node visibilities - std::vector nodesVisible; - nodesVisible.resize(3); - std::fill(nodesVisible.begin(), nodesVisible.end(), true); - - // which node has the level window - std::vector nodesForLevelWindow; - nodesForLevelWindow.resize(3); - std::fill(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), false); - - // the nodes themselves - std::vector nodes; - nodes.push_back(node1); - nodes.push_back(node2); - nodes.push_back(node3); - - // status quo - manager->SetAutoTopMostImage(false); - - bool lvlWin1, lvlWin2, lvlWin3; - node1->GetBoolProperty("imageForLevelWindow", lvlWin1); - node2->GetBoolProperty("imageForLevelWindow", lvlWin2); - node3->GetBoolProperty("imageForLevelWindow", lvlWin3); - - MITK_TEST_CONDITION(lvlWin1 && !lvlWin2 && !lvlWin3, "Testing initial imageForLevelWindow setting."); - - nodesForLevelWindow[0] = lvlWin1; - nodesForLevelWindow[1] = lvlWin2; - nodesForLevelWindow[2] = lvlWin3; - - // prepare randomized visibility changes - RandomGeneratorType::Pointer ranGen = RandomGeneratorType::New(); - ranGen->Initialize(); - - int ranCount = 100; - int validCount = 0; - int invalidCount = 0; - int mustHaveLvlWindow = 4; - for (int run = 0; run < ranCount; ++run) - { - // toggle node visibility - int ran = ranGen->GetIntegerVariate(2); - nodes[ran]->SetBoolProperty("imageForLevelWindow", !nodesForLevelWindow[ran]); - - // one node must have the level window - std::vector::const_iterator found = std::find(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), true); - if (found == nodesForLevelWindow.end()) - { - break; - } - - // all invisible? - found = std::find(nodesVisible.begin(), nodesVisible.end(), true); - - if (!nodesForLevelWindow[ran]) - { - mustHaveLvlWindow = pow(2, 2 - ran); - } - else - { - mustHaveLvlWindow = 4; - } - - // get the current status - node1->GetBoolProperty("imageForLevelWindow", lvlWin1); - node2->GetBoolProperty("imageForLevelWindow", lvlWin2); - node3->GetBoolProperty("imageForLevelWindow", lvlWin3); - nodesForLevelWindow[0] = lvlWin1; - nodesForLevelWindow[1] = lvlWin2; - nodesForLevelWindow[2] = lvlWin3; - - int hasLevelWindow = 0; - for (int i = 0; i < 3; ++i) - { - if (nodesForLevelWindow[i]) - { - hasLevelWindow += pow(2, 2 - i); - } - } - - validCount += hasLevelWindow == mustHaveLvlWindow ? 1 : 0; - - // test sensitivity - int falseran = 0; - while (falseran == 0) - { - falseran = ranGen->GetIntegerVariate(7); - } - BoolVecType falseNodes; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin1 : lvlWin1); - falseran >>= 1; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin2 : lvlWin2); - falseran >>= 1; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin3 : lvlWin3); - int falseLevelWindow = 0; - for (int i = 0; i < 3; ++i) - { - if (falseNodes[i]) - { - falseLevelWindow += pow(2, 2 - i); - } - } - - invalidCount += falseLevelWindow == mustHaveLvlWindow ? 0 : 1; - - // in case of errors proceed anyway - mustHaveLvlWindow = hasLevelWindow; - } + m_LevelWindowManager->SetSelectedImages(true); + m_DataNode1->SetSelected(true); // selection mode enabled - node1 becomes the "imageForLevelWindow" node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode2->SetIntProperty("layer", itk::NumericTraits::max()); // selection mode enabled - node1 stays the "imageForLevelWindow" node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode1->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR)); // selection mode enabled - but node1 is ignored - no active level window property + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + + m_DataNode3->SetBoolProperty("imageForLevelWindow", true); // selection mode enabled - no valid node selected, no active level window property + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + + m_LevelWindowManager->SetSelectedImages(false); // no mode enabled - however, level window is not modified / updated + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + + m_LevelWindowManager->Update(itk::ModifiedEvent()); // no mode enabled - level window is modified / updated with topmost visible node2 as fallback + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode3->SetBoolProperty("imageForLevelWindow", true); // no mode enabled - use node3 with "imageForLevelWindow" property set + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + + m_DataNode3->SetVisibility(false); // node3 with "imageForLevelWindow" property not visible - use topmost visible node2 as fallback + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode2->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); // fallback node2 is ignored - but "imageForLevelWindow" and "levelWindow" stay "true" for node2 + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_LevelWindowManager->SetAutoTopMostImage(true); // no visible node exists that is not ignored + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, false)); + + auto levelWindowProperty = dynamic_cast(m_DataNode3->GetProperty("levelwindow")); + m_LevelWindowManager->SetLevelWindowProperty(levelWindowProperty); // explicitely set the level window to node3 + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); + + m_DataNode1->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR)); // auto topmost mode enabled - node1 is the only visible non-ignored node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode2->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New( + mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR)); // auto topmost mode enabled - node2 is topmost visible node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, true, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, true, false)); + + m_DataNode2->SetIntProperty("layer", itk::NumericTraits::min()); // auto topmost mode enabled - node1 is topmost visible node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(true, false, false)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(true, false, false)); + + m_DataNode3->SetVisibility(true); // auto topmost mode enabled - node3 is topmost visible node + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", AssertImageForLevelWindowProperty(false, false, true)); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", AssertLevelWindowProperty(false, false, true)); - MITK_TEST_CONDITION(validCount == ranCount, "Testing proper node for level window property."); - MITK_TEST_CONDITION(invalidCount == ranCount, "Sensitivity test."); } - static void TestImageForLevelWindowOnRandomVisibilityChange(std::string testImageFile) + void TestRemoveDataNodes() { - typedef std::vector BoolVecType; - typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; - - // initialize the data storage - mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New(); - mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); - manager->SetDataStorage(ds); - - mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0); - - node3->SetIntProperty("layer", 1); - node2->SetIntProperty("layer", 2); - node1->SetIntProperty("layer", 3); - - // node visibilities - std::vector nodesVisible; - nodesVisible.resize(3); - std::fill(nodesVisible.begin(), nodesVisible.end(), true); - - // which node has the level window - std::vector nodesForLevelWindow; - nodesForLevelWindow.resize(3); - std::fill(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), false); - - // the nodes themselves - std::vector nodes; - nodes.push_back(node1); - nodes.push_back(node2); - nodes.push_back(node3); - - // status quo - manager->SetAutoTopMostImage(false); - - bool lvlWin1, lvlWin2, lvlWin3; - node1->GetBoolProperty("imageForLevelWindow", lvlWin1); - node2->GetBoolProperty("imageForLevelWindow", lvlWin2); - node3->GetBoolProperty("imageForLevelWindow", lvlWin3); - - MITK_TEST_CONDITION(lvlWin1 && !lvlWin2 && !lvlWin3, "Testing initial imageForLevelWindow setting."); - - nodesForLevelWindow[0] = lvlWin1; - nodesForLevelWindow[1] = lvlWin2; - nodesForLevelWindow[2] = lvlWin3; - - // prepare randomized visibility changes - RandomGeneratorType::Pointer ranGen = RandomGeneratorType::New(); - ranGen->Initialize(); - - int ranCount = 100; - int validCount = 0; - int invalidCount = 0; - int mustHaveLvlWindow = 4; - for (int run = 0; run < ranCount; ++run) - { - // toggle node visibility - int ran = ranGen->GetIntegerVariate(2); - nodesVisible[ran] = !nodesVisible[ran]; - nodes[ran]->SetVisibility(nodesVisible[ran]); - - // one node must have the level window - std::vector::const_iterator found = std::find(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), true); - if (found == nodesForLevelWindow.end()) - { - break; - } - int ind = found - nodesForLevelWindow.begin(); - - // all invisible? - found = std::find(nodesVisible.begin(), nodesVisible.end(), true); - bool allInvisible = (found == nodesVisible.end()); - - // which node shall get the level window now - if (!allInvisible && !nodesVisible[ind]) - { - int count = 0; - for (std::vector::const_iterator it = nodesVisible.begin(); it != nodesVisible.end(); ++it, ++count) - { - if (*it) - { - mustHaveLvlWindow = pow(2, 2 - count); - break; - } - } - } - - // get the current status - node1->GetBoolProperty("imageForLevelWindow", lvlWin1); - node2->GetBoolProperty("imageForLevelWindow", lvlWin2); - node3->GetBoolProperty("imageForLevelWindow", lvlWin3); - nodesForLevelWindow[0] = lvlWin1; - nodesForLevelWindow[1] = lvlWin2; - nodesForLevelWindow[2] = lvlWin3; - - int hasLevelWindow = 0; - for (int i = 0; i < 3; ++i) - { - if (nodesForLevelWindow[i]) - { - hasLevelWindow += pow(2, 2 - i); - } - } - - validCount += hasLevelWindow == mustHaveLvlWindow ? 1 : 0; - - // test sensitivity - int falseran = 0; - while (falseran == 0) - { - falseran = ranGen->GetIntegerVariate(7); - } - BoolVecType falseNodes; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin1 : lvlWin1); - falseran >>= 1; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin2 : lvlWin2); - falseran >>= 1; - falseNodes.push_back((falseran & 1) == 1 ? !lvlWin3 : lvlWin3); - int falseLevelWindow = 0; - for (int i = 0; i < 3; ++i) - { - if (falseNodes[i]) - { - falseLevelWindow += pow(2, 2 - i); - } - } - - invalidCount += falseLevelWindow == mustHaveLvlWindow ? 0 : 1; - - // in case of errors proceed anyway - mustHaveLvlWindow = hasLevelWindow; - } - - MITK_TEST_CONDITION(validCount == ranCount, "Testing proper node for level window property."); - MITK_TEST_CONDITION(invalidCount == ranCount, "Sensitivity test."); + m_DataManager->Remove(m_DataNode3); + CPPUNIT_ASSERT_MESSAGE("Node not correctly removed", m_LevelWindowManager->GetRelevantNodes()->size() == 2); + CPPUNIT_ASSERT_MESSAGE("Observer not correctly removed", m_LevelWindowManager->GetNumberOfObservers() == 2); + + bool isImageForLevelWindow1, isImageForLevelWindow2; + m_DataNode1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); + m_DataNode2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", !isImageForLevelWindow1 && isImageForLevelWindow2); + + auto levelWindowProperty1 = dynamic_cast(m_DataNode1->GetProperty("levelwindow")); + auto levelWindowProperty2 = dynamic_cast(m_DataNode2->GetProperty("levelwindow")); + auto managerLevelWindowProperty = m_LevelWindowManager->GetLevelWindowProperty(); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", + (false == (managerLevelWindowProperty == levelWindowProperty1)) && + (true == (managerLevelWindowProperty == levelWindowProperty2))); + + m_DataManager->Remove(m_DataNode2); + CPPUNIT_ASSERT_MESSAGE("Node not correctly removed", m_LevelWindowManager->GetRelevantNodes()->size() == 1); + CPPUNIT_ASSERT_MESSAGE("Observer not correctly removed", m_LevelWindowManager->GetNumberOfObservers() == 1); + + m_DataNode1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1); + CPPUNIT_ASSERT_MESSAGE("\"imageForLevelWindow\" property not correctly set", isImageForLevelWindow1); + + levelWindowProperty1 = dynamic_cast(m_DataNode1->GetProperty("levelwindow")); + managerLevelWindowProperty = m_LevelWindowManager->GetLevelWindowProperty(); + CPPUNIT_ASSERT_MESSAGE("\"levelwindow\" property not correctly set", true == (managerLevelWindowProperty == levelWindowProperty1)); + + m_DataManager->Remove(m_DataNode1); + CPPUNIT_ASSERT_MESSAGE("Node not correctly removed", m_LevelWindowManager->GetRelevantNodes()->size() == 0); + CPPUNIT_ASSERT_MESSAGE("Observer not correctly removed", m_LevelWindowManager->GetNumberOfObservers() == 0); + + CPPUNIT_ASSERT_MESSAGE("LevelWindowProperty is not null", !m_LevelWindowManager->GetLevelWindowProperty()); } }; -int mitkLevelWindowManagerTest(int argc, char *args[]) -{ - MITK_TEST_BEGIN("mitkLevelWindowManager"); - - MITK_TEST_CONDITION_REQUIRED(argc >= 2, "Testing if test file is given."); - std::string testImage = args[1]; - - mitkLevelWindowManagerTestClass::TestInstantiation(); - mitkLevelWindowManagerTestClass::TestSetGetDataStorage(); - mitkLevelWindowManagerTestClass::TestMethodsWithInvalidParameters(); - mitkLevelWindowManagerTestClass::TestOtherMethods(); - mitkLevelWindowManagerTestClass::TestRemoveObserver(testImage); - mitkLevelWindowManagerTestClass::TestLevelWindowSliderVisibility(testImage); - mitkLevelWindowManagerTestClass::TestSetLevelWindowProperty(testImage); - mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnVisibilityChange(testImage); - mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnRandomVisibilityChange(testImage); - mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnRandomPropertyChange(testImage); - - MITK_TEST_END(); -} +MITK_TEST_SUITE_REGISTRATION(mitkLevelWindowManager) diff --git a/Modules/QtWidgets/src/QmitkLevelWindowWidgetContextMenu.cpp b/Modules/QtWidgets/src/QmitkLevelWindowWidgetContextMenu.cpp index dfd7b828f6..dd290731b4 100644 --- a/Modules/QtWidgets/src/QmitkLevelWindowWidgetContextMenu.cpp +++ b/Modules/QtWidgets/src/QmitkLevelWindowWidgetContextMenu.cpp @@ -1,301 +1,304 @@ /*============================================================================ 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. ============================================================================*/ #include // mitk core #include // mitk qt widgets #include "QmitkLevelWindowPresetDefinitionDialog.h" #include "QmitkLevelWindowRangeChangeDialog.h" // qt #include QmitkLevelWindowWidgetContextMenu::QmitkLevelWindowWidgetContextMenu(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f) { m_LevelWindowPreset = mitk::LevelWindowPreset::New(); m_LevelWindowPreset->LoadPreset(); } QmitkLevelWindowWidgetContextMenu::~QmitkLevelWindowWidgetContextMenu() { m_LevelWindowPreset->Delete(); } void QmitkLevelWindowWidgetContextMenu::OnSetPreset(const QAction *presetAction) { QString item = presetAction->text(); if (!(presetAction == m_PresetAction)) { double dlevel = m_LevelWindowPreset->getLevel(item.toStdString()); double dwindow = m_LevelWindowPreset->getWindow(item.toStdString()); if ((dlevel + dwindow / 2) > m_LevelWindow.GetRangeMax()) { double lowerBound = (dlevel - dwindow / 2); if (!(lowerBound > m_LevelWindow.GetRangeMax())) { dwindow = m_LevelWindow.GetRangeMax() - lowerBound; dlevel = lowerBound + dwindow / 2; } else { dlevel = m_LevelWindow.GetRangeMax() - 1; dwindow = 2; } } else if ((dlevel - dwindow / 2) < m_LevelWindow.GetRangeMin()) { double upperBound = (dlevel + dwindow / 2); if (!(upperBound < m_LevelWindow.GetRangeMin())) { dwindow = m_LevelWindow.GetRangeMin() + upperBound; dlevel = upperBound - dwindow / 2; } else { dlevel = m_LevelWindow.GetRangeMin() + 1; dwindow = 2; } } m_LevelWindow.SetLevelWindow(dlevel, dwindow); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkLevelWindowWidgetContextMenu::SetLevelWindowManager(mitk::LevelWindowManager *levelWindowManager) { m_Manager = levelWindowManager; } void QmitkLevelWindowWidgetContextMenu::OnAddPreset() { QmitkLevelWindowPresetDefinitionDialog addPreset(this); addPreset.setPresets(m_LevelWindowPreset->getLevelPresets(), m_LevelWindowPreset->getWindowPresets(), QString::number((int)m_LevelWindow.GetLevel()), QString::number((int)m_LevelWindow.GetWindow())); if (addPreset.exec()) { m_LevelWindowPreset->newPresets(addPreset.getLevelPresets(), addPreset.getWindowPresets()); } } void QmitkLevelWindowWidgetContextMenu::OnSetFixed() { m_LevelWindow.SetFixed(!m_LevelWindow.GetFixed()); m_Manager->SetLevelWindow(m_LevelWindow); } void QmitkLevelWindowWidgetContextMenu::OnUseAllGreyvaluesFromImage() { m_LevelWindow.SetToImageRange(m_Manager->GetCurrentImage()); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkLevelWindowWidgetContextMenu::OnUseOptimizedLevelWindow() { m_LevelWindow.SetAuto(m_Manager->GetCurrentImage(), false, false); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkLevelWindowWidgetContextMenu::OnSetDefaultLevelWindow() { m_LevelWindow.ResetDefaultLevelWindow(); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkLevelWindowWidgetContextMenu::OnSetMaximumWindow() { m_LevelWindow.SetToMaxWindowSize(); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkLevelWindowWidgetContextMenu::OnSetDefaultScaleRange() { m_LevelWindow.ResetDefaultRangeMinMax(); m_LevelWindow.SetLevelWindow(m_LevelWindow.GetLevel(), m_LevelWindow.GetWindow()); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkLevelWindowWidgetContextMenu::OnChangeScaleRange() { QmitkLevelWindowRangeChangeDialog changeRange(this); changeRange.setLowerLimit((mitk::ScalarType)m_LevelWindow.GetRangeMin()); changeRange.setUpperLimit((mitk::ScalarType)m_LevelWindow.GetRangeMax()); if (changeRange.exec()) { m_LevelWindow.SetRangeMinMax(changeRange.getLowerLimit(), changeRange.getUpperLimit()); m_LevelWindow.SetLevelWindow(m_LevelWindow.GetLevel(), m_LevelWindow.GetWindow()); m_Manager->SetLevelWindow(m_LevelWindow); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkLevelWindowWidgetContextMenu::OnSetImage(QAction *imageAction) { if (imageAction == m_AutoTopmostAction) { if (m_Manager->IsAutoTopMost() == false) { m_Manager->SetAutoTopMostImage(true); + m_SelectedImagesAction->setChecked(false); } else { m_Manager->SetAutoTopMostImage(false); } } else if(imageAction == m_SelectedImagesAction) { if (m_Manager->IsSelectedImages() == false) { m_Manager->SetSelectedImages(true); + m_AutoTopmostAction->setChecked(false); } else { m_Manager->SetSelectedImages(false); } } else { + m_AutoTopmostAction->setChecked(false); + m_SelectedImagesAction->setChecked(false); m_Manager->SetLevelWindowProperty(m_Images.at(imageAction)); } } void QmitkLevelWindowWidgetContextMenu::GetContextMenu(QMenu *contextMenu) { if (nullptr == contextMenu) { return; } try { m_LevelWindow = m_Manager->GetLevelWindow(); QAction *sliderFixed = contextMenu->addAction(tr("Set slider fixed"), this, &QmitkLevelWindowWidgetContextMenu::OnSetFixed); sliderFixed->setCheckable(true); sliderFixed->setChecked(m_LevelWindow.IsFixed()); contextMenu->addSeparator(); contextMenu->addAction(tr("Use whole image grey values"), this, &QmitkLevelWindowWidgetContextMenu::OnUseAllGreyvaluesFromImage); contextMenu->addAction(tr("Use optimized level-window"), this, &QmitkLevelWindowWidgetContextMenu::OnUseOptimizedLevelWindow); contextMenu->addSeparator(); contextMenu->addAction(tr("Set maximum window"), this, &QmitkLevelWindowWidgetContextMenu::OnSetMaximumWindow); contextMenu->addAction(tr("Default level-window"), this, &QmitkLevelWindowWidgetContextMenu::OnSetDefaultLevelWindow); contextMenu->addSeparator(); contextMenu->addAction(tr("Change scale range"), this, &QmitkLevelWindowWidgetContextMenu::OnChangeScaleRange); contextMenu->addAction(tr("Default scale range"), this, &QmitkLevelWindowWidgetContextMenu::OnSetDefaultScaleRange); contextMenu->addSeparator(); m_PresetSubmenu = new QMenu(this); m_PresetSubmenu->setTitle("Presets"); m_PresetAction = m_PresetSubmenu->addAction(tr("Preset definition"), this, &QmitkLevelWindowWidgetContextMenu::OnAddPreset); m_PresetSubmenu->addSeparator(); std::map preset = m_LevelWindowPreset->getLevelPresets(); for (auto iter = preset.begin(); iter != preset.end(); iter++) { QString item = ((*iter).first.c_str()); m_PresetSubmenu->addAction(item); } connect(m_PresetSubmenu, &QMenu::triggered, this, &QmitkLevelWindowWidgetContextMenu::OnSetPreset); contextMenu->addMenu(m_PresetSubmenu); contextMenu->addSeparator(); m_ImageSubmenu = new QMenu(this); m_ImageSubmenu->setTitle("Images"); // add action for "auto topmost image" action m_AutoTopmostAction = m_ImageSubmenu->addAction(tr("Set topmost image")); m_AutoTopmostAction->setCheckable(true); if (m_Manager->IsAutoTopMost()) { m_AutoTopmostAction->setChecked(true); } // add action for "selected images" action - m_ImageSubmenu->addSeparator(); m_SelectedImagesAction = m_ImageSubmenu->addAction(tr("Use selected images")); m_SelectedImagesAction->setCheckable(true); if (m_Manager->IsSelectedImages()) { m_SelectedImagesAction->setChecked(true); } // add action for individual images m_ImageSubmenu->addSeparator(); mitk::DataStorage::SetOfObjects::ConstPointer allObjects = m_Manager->GetRelevantNodes(); for (mitk::DataStorage::SetOfObjects::ConstIterator objectIter = allObjects->Begin(); objectIter != allObjects->End(); ++objectIter) { mitk::DataNode *node = objectIter->Value(); if (nullptr == node) { continue; } bool isHelperObject = false; node->GetBoolProperty("helper object", isHelperObject); if (isHelperObject) { continue; } if (!node->IsVisible(nullptr)) { continue; } mitk::LevelWindowProperty::Pointer levelWindowProperty = dynamic_cast(node->GetProperty("levelwindow")); if (levelWindowProperty.IsNotNull()) { std::string name; node->GetName(name); QString item = name.c_str(); QAction *id = m_ImageSubmenu->addAction(item); id->setCheckable(true); m_Images[id] = levelWindowProperty; if (levelWindowProperty == m_Manager->GetLevelWindowProperty()) { id->setChecked(true); } } } connect(m_ImageSubmenu, &QMenu::triggered, this, &QmitkLevelWindowWidgetContextMenu::OnSetImage); contextMenu->addMenu(m_ImageSubmenu); contextMenu->exec(QCursor::pos()); } catch (...) { } } void QmitkLevelWindowWidgetContextMenu::GetContextMenu() { auto contextMenu = new QMenu(this); GetContextMenu(contextMenu); delete contextMenu; }