diff --git a/Modules/Segmentation/Controllers/mitkToolManager.cpp b/Modules/Segmentation/Controllers/mitkToolManager.cpp
index 6e2fbd852c..3a58986d92 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.cpp
+++ b/Modules/Segmentation/Controllers/mitkToolManager.cpp
@@ -1,589 +1,596 @@
/*============================================================================
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 "mitkToolManager.h"
#include "mitkToolManagerProvider.h"
#include "mitkCoreObjectFactory.h"
#include <itkCommand.h>
#include <itkObjectFactoryBase.h>
#include <list>
#include "mitkInteractionEventObserver.h"
#include "mitkSegTool2D.h"
#include "mitkRenderingManager.h"
#include "mitkSliceNavigationController.h"
#include "usGetModuleContext.h"
#include "usModuleContext.h"
mitk::ToolManager::ToolManager(DataStorage *storage)
: m_ActiveTool(nullptr), m_ActiveToolID(-1), m_RegisteredClients(0), m_DataStorage(storage)
{
CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools
// are registered) - bug 1029
this->InitializeTools();
}
void mitk::ToolManager::EnsureTimeObservation()
{
if (nullptr != mitk::RenderingManager::GetInstance() && nullptr != mitk::RenderingManager::GetInstance()->GetTimeNavigationController())
{
auto timeController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
m_LastTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
auto currentTimeController = m_CurrentTimeNavigationController.Lock();
if (timeController != currentTimeController)
{
if (currentTimeController.IsNotNull())
{
currentTimeController->RemoveObserver(m_TimePointObserverTag);
}
itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
command->SetCallbackFunction(this, &ToolManager::OnTimeChanged);
command->SetCallbackFunction(this, &ToolManager::OnTimeChangedConst);
m_CurrentTimeNavigationController = timeController;
m_TimePointObserverTag = timeController->AddObserver(SliceNavigationController::GeometryTimeEvent(nullptr,0), command);
}
}
}
void mitk::ToolManager::StopTimeObservation()
{
auto currentTimeController = m_CurrentTimeNavigationController.Lock();
if (currentTimeController.IsNotNull())
{
currentTimeController->RemoveObserver(m_TimePointObserverTag);
m_CurrentTimeNavigationController = nullptr;
m_TimePointObserverTag = 0;
}
}
mitk::ToolManager::~ToolManager()
{
for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
(*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
if (this->GetDataStorage() != nullptr)
this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
if (m_ActiveTool)
{
m_ActiveTool->Deactivated();
m_ActiveToolRegistration.Unregister();
m_ActiveTool = nullptr;
m_ActiveToolID = -1; // no tool active
ActiveToolChanged.Send();
}
for (auto observerTagMapIter = m_ReferenceDataObserverTags.begin();
observerTagMapIter != m_ReferenceDataObserverTags.end();
++observerTagMapIter)
{
observerTagMapIter->first->RemoveObserver(observerTagMapIter->second);
}
this->StopTimeObservation();
}
void mitk::ToolManager::InitializeTools()
{
// clear all previous tool pointers (tools may be still activated from another recently used plugin)
if (m_ActiveTool)
{
m_ActiveTool->Deactivated();
m_ActiveToolRegistration.Unregister();
m_ActiveTool = nullptr;
m_ActiveToolID = -1; // no tool active
ActiveToolChanged.Send();
}
m_Tools.clear();
// get a list of all known mitk::Tools
std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
// remember these tools
for (auto iter = thingsThatClaimToBeATool.begin();
iter != thingsThatClaimToBeATool.end();
++iter)
{
if (auto *tool = dynamic_cast<Tool *>(iter->GetPointer()))
{
tool->InitializeStateMachine();
tool->SetToolManager(this); // important to call right after instantiation
tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>(this, &ToolManager::OnToolErrorMessage);
tool->GeneralMessage +=
MessageDelegate1<mitk::ToolManager, std::string>(this, &ToolManager::OnGeneralToolMessage);
m_Tools.push_back(tool);
}
}
}
void mitk::ToolManager::OnToolErrorMessage(std::string s)
{
this->ToolErrorMessage(s);
}
void mitk::ToolManager::OnGeneralToolMessage(std::string s)
{
this->GeneralToolMessage(s);
}
const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
{
ToolVectorTypeConst resultList;
for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter)
{
resultList.push_back(iter->GetPointer());
}
return resultList;
}
mitk::Tool *mitk::ToolManager::GetToolById(int id)
{
try
{
return m_Tools.at(id);
}
catch (const std::exception &)
{
return nullptr;
}
}
bool mitk::ToolManager::ActivateTool(int id)
{
- if (id != -1 && !this->GetToolById(id)->CanHandle(this->GetReferenceData(0)->GetData()))
+ const auto workingDataNode = this->GetWorkingData(0);
+ const mitk::BaseData* workingData = nullptr;
+ if (nullptr != workingDataNode)
+ {
+ workingData = workingDataNode->GetData();
+ }
+
+ if (id != -1 && !this->GetToolById(id)->CanHandle(this->GetReferenceData(0)->GetData(), workingData))
return false;
if (this->GetDataStorage())
{
this->GetDataStorage()->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
}
if (GetToolById(id) == m_ActiveTool)
return true; // no change needed
static int nextTool = -1;
nextTool = id;
static bool inActivateTool = false;
if (inActivateTool)
{
return true;
}
inActivateTool = true;
while (nextTool != m_ActiveToolID)
{
// Deactivate all other active tools to ensure a globally single active tool
for (const auto& toolManager : ToolManagerProvider::GetInstance()->GetToolManagers())
{
if (nullptr != toolManager.second->m_ActiveTool)
{
toolManager.second->m_ActiveTool->Deactivated();
toolManager.second->m_ActiveToolRegistration.Unregister();
// The active tool of *this* ToolManager is handled below this loop
if (this != toolManager.second)
{
toolManager.second->m_ActiveTool = nullptr;
toolManager.second->m_ActiveToolID = -1;
toolManager.second->ActiveToolChanged.Send();
}
}
}
m_ActiveTool = GetToolById(nextTool);
m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
ActiveToolChanged.Send();
if (m_ActiveTool)
{
this->EnsureTimeObservation();
if (m_RegisteredClients > 0)
{
m_ActiveTool->Activated();
m_ActiveToolRegistration =
us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
}
}
}
inActivateTool = false;
return (m_ActiveTool != nullptr);
}
void mitk::ToolManager::SetReferenceData(DataVectorType data)
{
if (data != m_ReferenceData)
{
// remove observers from old nodes
for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
{
auto searchIter = m_ReferenceDataObserverTags.find(*dataIter);
if (searchIter != m_ReferenceDataObserverTags.end())
{
(*dataIter)->RemoveObserver(searchIter->second);
}
}
m_ReferenceData = data;
// TODO tell active tool?
// attach new observers
m_ReferenceDataObserverTags.clear();
for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
{
itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheReferenceDataDeleted);
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheReferenceDataDeletedConst);
m_ReferenceDataObserverTags.insert(
std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
}
ReferenceDataChanged.Send();
}
}
void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
{
OnOneOfTheReferenceDataDeleted(const_cast<itk::Object *>(caller), e);
}
void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
{
DataVectorType v;
for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
{
if ((void *)(*dataIter) != (void *)caller)
{
v.push_back(*dataIter);
}
else
{
m_ReferenceDataObserverTags.erase(*dataIter); // no tag to remove anymore
}
}
this->SetReferenceData(v);
}
void mitk::ToolManager::SetReferenceData(DataNode *data)
{
DataVectorType v;
if (data)
{
v.push_back(data);
}
SetReferenceData(v);
}
void mitk::ToolManager::SetWorkingData(DataVectorType data)
{
if (data != m_WorkingData)
{
// remove observers from old nodes
for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
{
auto searchIter = m_WorkingDataObserverTags.find(*dataIter);
if (searchIter != m_WorkingDataObserverTags.end())
{
(*dataIter)->RemoveObserver(searchIter->second);
}
}
m_WorkingData = data;
// TODO tell active tool?
// Quick workaround for bug #16598
if (m_WorkingData.empty())
this->ActivateTool(-1);
// workaround end
// attach new observers
m_WorkingDataObserverTags.clear();
for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
{
itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheWorkingDataDeleted);
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheWorkingDataDeletedConst);
m_WorkingDataObserverTags.insert(
std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
}
WorkingDataChanged.Send();
}
}
void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
{
OnOneOfTheWorkingDataDeleted(const_cast<itk::Object *>(caller), e);
}
void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
{
DataVectorType v;
for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
{
if ((void *)(*dataIter) != (void *)caller)
{
v.push_back(*dataIter);
}
else
{
m_WorkingDataObserverTags.erase(*dataIter); // no tag to remove anymore
}
}
this->SetWorkingData(v);
}
void mitk::ToolManager::SetWorkingData(DataNode *data)
{
DataVectorType v;
if (data) // don't allow for nullptr nodes
{
v.push_back(data);
}
SetWorkingData(v);
}
void mitk::ToolManager::SetRoiData(DataVectorType data)
{
if (data != m_RoiData)
{
// remove observers from old nodes
for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
{
auto searchIter = m_RoiDataObserverTags.find(*dataIter);
if (searchIter != m_RoiDataObserverTags.end())
{
(*dataIter)->RemoveObserver(searchIter->second);
}
}
m_RoiData = data;
// TODO tell active tool?
// attach new observers
m_RoiDataObserverTags.clear();
for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
{
itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheRoiDataDeleted);
command->SetCallbackFunction(this, &ToolManager::OnOneOfTheRoiDataDeletedConst);
m_RoiDataObserverTags.insert(
std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
}
RoiDataChanged.Send();
}
}
void mitk::ToolManager::SetRoiData(DataNode *data)
{
DataVectorType v;
if (data)
{
v.push_back(data);
}
this->SetRoiData(v);
}
void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
{
OnOneOfTheRoiDataDeleted(const_cast<itk::Object *>(caller), e);
}
void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
{
DataVectorType v;
for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
{
if ((void *)(*dataIter) != (void *)caller)
{
v.push_back(*dataIter);
}
else
{
m_RoiDataObserverTags.erase(*dataIter); // no tag to remove anymore
}
}
this->SetRoiData(v);
}
mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
{
return m_ReferenceData;
}
mitk::DataNode *mitk::ToolManager::GetReferenceData(int idx)
{
try
{
return m_ReferenceData.at(idx);
}
catch (const std::exception &)
{
return nullptr;
}
}
mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
{
return m_WorkingData;
}
mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
{
return m_RoiData;
}
mitk::DataNode *mitk::ToolManager::GetRoiData(int idx)
{
try
{
return m_RoiData.at(idx);
}
catch (const std::exception &)
{
return nullptr;
}
}
mitk::DataStorage *mitk::ToolManager::GetDataStorage()
{
if (!m_DataStorage.IsExpired())
{
return m_DataStorage.Lock();
}
else
{
return nullptr;
}
}
void mitk::ToolManager::SetDataStorage(DataStorage &storage)
{
m_DataStorage = &storage;
}
mitk::DataNode *mitk::ToolManager::GetWorkingData(unsigned int idx)
{
if (m_WorkingData.empty())
return nullptr;
if (m_WorkingData.size() > idx)
return m_WorkingData[idx];
return nullptr;
}
int mitk::ToolManager::GetActiveToolID()
{
return m_ActiveToolID;
}
mitk::Tool *mitk::ToolManager::GetActiveTool()
{
return m_ActiveTool;
}
void mitk::ToolManager::RegisterClient()
{
if (m_RegisteredClients < 1)
{
if (m_ActiveTool)
{
m_ActiveTool->Activated();
m_ActiveToolRegistration =
us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
}
}
++m_RegisteredClients;
}
void mitk::ToolManager::UnregisterClient()
{
if (m_RegisteredClients < 1)
return;
--m_RegisteredClients;
if (m_RegisteredClients < 1)
{
if (m_ActiveTool)
{
m_ActiveTool->Deactivated();
m_ActiveToolRegistration.Unregister();
}
}
}
int mitk::ToolManager::GetToolID(const Tool *tool)
{
int id(0);
for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter, ++id)
{
if (tool == iter->GetPointer())
{
return id;
}
}
return -1;
}
void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode *node)
{
// check all storage vectors
OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
}
void mitk::ToolManager::OnTimeChanged(itk::Object* caller, const itk::EventObject& e)
{
this->OnTimeChangedConst(caller, e);
}
void mitk::ToolManager::OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& /*e*/)
{
auto currentController = m_CurrentTimeNavigationController.Lock();
if (caller == currentController)
{
const auto currentTimePoint = currentController->GetSelectedTimePoint();
if (currentTimePoint != m_LastTimePoint)
{
m_LastTimePoint = currentTimePoint;
SelectedTimePointChanged.Send();
}
}
}
mitk::TimePointType mitk::ToolManager::GetCurrentTimePoint() const
{
return m_LastTimePoint;
}
diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
index 306d0fcac8..64de93da55 100644
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
@@ -1,117 +1,117 @@
/*============================================================================
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 "mitkAdaptiveRegionGrowingTool.h"
#include "mitkImage.h"
#include "mitkProperties.h"
#include "mitkToolManager.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, AdaptiveRegionGrowingTool, "AdaptiveRegionGrowingTool");
}
mitk::AdaptiveRegionGrowingTool::AdaptiveRegionGrowingTool()
{
m_PointSetNode = mitk::DataNode::New();
m_PointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New("3D_Regiongrowing_Seedpoint"));
m_PointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PointSet = mitk::PointSet::New();
m_PointSetNode->SetData(m_PointSet);
}
mitk::AdaptiveRegionGrowingTool::~AdaptiveRegionGrowingTool()
{
}
-bool mitk::AdaptiveRegionGrowingTool::CanHandle(BaseData *referenceData) const
+bool mitk::AdaptiveRegionGrowingTool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
{
if (referenceData == nullptr)
return false;
- auto *image = dynamic_cast<Image *>(referenceData);
+ auto *image = dynamic_cast<const Image *>(referenceData);
if (image == nullptr)
return false;
if (image->GetDimension() < 3)
return false;
return true;
}
const char **mitk::AdaptiveRegionGrowingTool::GetXPM() const
{
return nullptr;
}
const char *mitk::AdaptiveRegionGrowingTool::GetName() const
{
return "Region Growing 3D";
}
us::ModuleResource mitk::AdaptiveRegionGrowingTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
return resource;
}
void mitk::AdaptiveRegionGrowingTool::Activated()
{
Superclass::Activated();
if (!GetDataStorage()->Exists(m_PointSetNode))
GetDataStorage()->Add(m_PointSetNode, GetWorkingData());
m_SeedPointInteractor = mitk::SinglePointDataInteractor::New();
m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
m_SeedPointInteractor->SetDataNode(m_PointSetNode);
}
void mitk::AdaptiveRegionGrowingTool::Deactivated()
{
m_PointSet->Clear();
GetDataStorage()->Remove(m_PointSetNode);
Superclass::Deactivated();
}
void mitk::AdaptiveRegionGrowingTool::ConfirmSegmentation()
{
m_ToolManager->ActivateTool(-1);
}
mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetReferenceData()
{
return this->m_ToolManager->GetReferenceData(0);
}
mitk::DataStorage *mitk::AdaptiveRegionGrowingTool::GetDataStorage()
{
return this->m_ToolManager->GetDataStorage();
}
mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetWorkingData()
{
return this->m_ToolManager->GetWorkingData(0);
}
mitk::DataNode::Pointer mitk::AdaptiveRegionGrowingTool::GetPointSetNode()
{
return m_PointSetNode;
}
diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h
index 31797bffbc..7924978442 100644
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h
+++ b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h
@@ -1,128 +1,128 @@
/*============================================================================
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 mitkAdaptiveRegionGrowingTool_h_Included
#define mitkAdaptiveRegionGrowingTool_h_Included
#include "mitkAutoSegmentationTool.h"
#include "mitkCommon.h"
#include "mitkDataStorage.h"
#include "mitkPointSet.h"
#include "mitkSinglePointDataInteractor.h"
#include <MitkSegmentationExports.h>
namespace us
{
class ModuleResource;
}
namespace mitk
{
/**
\brief Dummy Tool for AdaptiveRegionGrowingToolGUI to get Tool functionality for AdaptiveRegionGrowing.
The actual logic is implemented in QmitkAdaptiveRegionGrowingToolGUI.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
class MITKSEGMENTATION_EXPORT AdaptiveRegionGrowingTool : public AutoSegmentationTool
{
public:
/**
* @brief mitkClassMacro
*/
mitkClassMacro(AdaptiveRegionGrowingTool, AutoSegmentationTool);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- bool CanHandle(BaseData *referenceData) const override;
+ bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
/**
* @brief Get XPM
* @return nullptr
*/
const char **GetXPM() const override;
/**
* @brief Get name
* @return name of the Tool
*/
const char *GetName() const override;
/**
* @brief Get icon resource
* @return the resource Object of the Icon
*/
us::ModuleResource GetIconResource() const override;
/**
* @brief Adds interactor for the seedpoint and creates a seedpoint if neccessary.
*
*
*/
void Activated() override;
/**
* @brief Removes all set points and interactors.
*
*
*/
void Deactivated() override;
/**
* @brief get pointset node
* @return the point set node
*/
virtual DataNode::Pointer GetPointSetNode();
/**
* @brief get reference data
* @return the current reference data.
*/
mitk::DataNode *GetReferenceData();
/**
* @brief Get working data
* @return a list of all working data.
*/
mitk::DataNode *GetWorkingData();
/**
* @brief Get datastorage
* @return the current data storage.
*/
mitk::DataStorage *GetDataStorage();
void ConfirmSegmentation();
protected:
/**
* @brief constructor
*/
AdaptiveRegionGrowingTool(); // purposely hidden
/**
* @brief destructor
*/
~AdaptiveRegionGrowingTool() override;
private:
PointSet::Pointer m_PointSet;
SinglePointDataInteractor::Pointer m_SeedPointInteractor;
DataNode::Pointer m_PointSetNode;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index 6b17128971..beed8f2c1a 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,330 +1,330 @@
/*============================================================================
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 "mitkTool.h"
#include <mitkAnatomicalStructureColorPresets.h>
#include "mitkDisplayInteractor.h"
#include "mitkDisplayActionEventBroadcast.h"
#include "mitkImageReadAccessor.h"
#include "mitkImageWriteAccessor.h"
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include <mitkDICOMSegmentationPropertyHelper.cpp>
// us
#include <usGetModuleContext.h>
#include <usModuleResource.h>
// itk
#include <itkObjectFactory.h>
mitk::Tool::Tool(const char *type, const us::Module *interactorModule)
: m_EventConfig("DisplayConfigMITK.xml"),
m_ToolManager(nullptr),
m_PredicateImages(NodePredicateDataType::New("Image")), // for reference images
m_PredicateDim3(NodePredicateDimension::New(3, 1)),
m_PredicateDim4(NodePredicateDimension::New(4, 1)),
m_PredicateDimension(mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4)),
m_PredicateImage3D(NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension)),
m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
m_PredicateNotBinary(NodePredicateNot::New(m_PredicateBinary)),
m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
m_PredicateNotSegmentation(NodePredicateNot::New(m_PredicateSegmentation)),
m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
m_PredicateNotHelper(NodePredicateNot::New(m_PredicateHelper)),
m_PredicateImageColorful(NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation)),
m_PredicateImageColorfulNotHelper(NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper)),
m_PredicateReference(NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper)),
m_IsSegmentationPredicate(
NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper)),
m_InteractorType(type),
m_DisplayInteractorConfigs(),
m_InteractorModule(interactorModule)
{
}
mitk::Tool::~Tool()
{
}
-bool mitk::Tool::CanHandle(BaseData *) const
+bool mitk::Tool::CanHandle(const BaseData* /*referenceData*/, const BaseData* /*workingData*/) const
{
return true;
}
void mitk::Tool::InitializeStateMachine()
{
if (m_InteractorType.empty())
return;
try
{
auto isThisModule = nullptr == m_InteractorModule;
auto module = isThisModule
? us::GetModuleContext()->GetModule()
: m_InteractorModule;
LoadStateMachine(m_InteractorType + ".xml", module);
SetEventConfig(isThisModule ? "SegmentationToolsConfig.xml" : m_InteractorType + "Config.xml", module);
}
catch (const std::exception &e)
{
MITK_ERROR << "Could not load statemachine pattern " << m_InteractorType << ".xml with exception: " << e.what();
}
}
void mitk::Tool::Notify(InteractionEvent *interactionEvent, bool isHandled)
{
// to use the state machine pattern,
// the event is passed to the state machine interface to be handled
if (!isHandled)
{
this->HandleEvent(interactionEvent, nullptr);
}
}
void mitk::Tool::ConnectActionsAndFunctions()
{
}
bool mitk::Tool::FilterEvents(InteractionEvent *, DataNode *)
{
return true;
}
const char *mitk::Tool::GetGroup() const
{
return "default";
}
void mitk::Tool::SetToolManager(ToolManager *manager)
{
m_ToolManager = manager;
}
void mitk::Tool::Activated()
{
// As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
// with tools
// Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
// will still be enabled
m_DisplayInteractorConfigs.clear();
std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
us::GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
for (auto it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
{
auto displayInteractor = dynamic_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayInteractor != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
// here the alternative configuration is loaded
displayInteractor->SetEventConfig(m_EventConfig.c_str());
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayActionEventBroadcast != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayActionEventBroadcast->GetEventConfig()));
// here the alternative configuration is loaded
displayActionEventBroadcast->SetEventConfig(m_EventConfig.c_str());
}
}
}
void mitk::Tool::Deactivated()
{
// Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
// in new interaction framework
for (auto it = m_DisplayInteractorConfigs.begin(); it != m_DisplayInteractorConfigs.end(); ++it)
{
if (it->first)
{
auto displayInteractor = static_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayInteractor != nullptr)
{
// here the regular configuration is loaded again
displayInteractor->SetEventConfig(it->second);
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayActionEventBroadcast != nullptr)
{
// here the regular configuration is loaded again
displayActionEventBroadcast->SetEventConfig(it->second);
}
}
}
m_DisplayInteractorConfigs.clear();
}
itk::Object::Pointer mitk::Tool::GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix)
{
itk::Object::Pointer object;
std::string classname = this->GetNameOfClass();
std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
for (auto iter = allGUIs.begin(); iter != allGUIs.end(); ++iter)
{
if (object.IsNull())
{
object = dynamic_cast<itk::Object *>(iter->GetPointer());
}
else
{
MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a "
<< guiClassname << " ) " << std::endl;
return nullptr; // people should see and fix this error
}
}
return object;
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
{
return m_PredicateReference.GetPointer();
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
{
return m_IsSegmentationPredicate.GetPointer();
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
const mitk::Color &color)
{
// we NEED a reference image for size etc.
if (!original)
return nullptr;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
LabelSetImage::Pointer segmentation = LabelSetImage::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
segmentation->Initialize(pixelType, 3, dimensions);
segmentation->AddLayer();
}
else
{
segmentation->Initialize(original);
}
mitk::Label::Pointer label = mitk::Label::New();
label->SetName(organName);
label->SetColor(color);
label->SetValue(1);
segmentation->GetActiveLabelSet()->AddLabel(label);
segmentation->GetActiveLabelSet()->SetActiveLabel(1);
unsigned int byteSize = sizeof(mitk::Label::PixelType);
if (segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
}
else
{
// if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
memset(writeAccess.GetData(), 0, byteSize);
}
}
if (original->GetTimeGeometry())
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry(originalGeometry);
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return nullptr;
}
return CreateSegmentationNode(segmentation, organName, color);
}
mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
const std::string &organName,
const mitk::Color &color)
{
if (!image)
return nullptr;
// decorate the datatreenode with some properties
DataNode::Pointer segmentationNode = DataNode::New();
segmentationNode->SetData(image);
// name
segmentationNode->SetProperty("name", StringProperty::New(organName));
// visualization properties
segmentationNode->SetProperty("binary", BoolProperty::New(true));
segmentationNode->SetProperty("color", ColorProperty::New(color));
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
lut->SetType(mitk::LookupTable::MULTILABEL);
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
lutProp->SetLookupTable(lut);
segmentationNode->SetProperty("LookupTable", lutProp);
segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
segmentationNode->SetProperty("layer", IntProperty::New(10));
segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
segmentationNode->SetProperty("reslice interpolation",
VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
// slices sometimes (only visual effect, not
// different data)
// For MITK-3M3 release, the volume of all segmentations should be shown
segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
return segmentationNode;
}
us::ModuleResource mitk::Tool::GetIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
us::ModuleResource mitk::Tool::GetCursorIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.h b/Modules/Segmentation/Interactions/mitkTool.h
index e9110e2a7a..16b2cf15a9 100644
--- a/Modules/Segmentation/Interactions/mitkTool.h
+++ b/Modules/Segmentation/Interactions/mitkTool.h
@@ -1,265 +1,270 @@
/*============================================================================
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 mitkTool_h_Included
#define mitkTool_h_Included
#include "itkObjectFactoryBase.h"
#include "itkVersion.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkEventStateMachine.h"
#include "mitkInteractionEventObserver.h"
#include "mitkLabelSetImage.h"
#include "mitkMessage.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateDimension.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateOr.h"
#include "mitkNodePredicateProperty.h"
#include "mitkToolEvents.h"
#include "mitkToolFactoryMacro.h"
#include <MitkSegmentationExports.h>
#include <mitkLabel.h>
#include <iostream>
#include <map>
#include <string>
#include <itkObject.h>
#include "usServiceRegistration.h"
namespace us
{
class ModuleResource;
}
namespace mitk
{
class ToolManager;
/**
\brief Base class of all tools used by mitk::ToolManager.
\sa ToolManager
\sa SegTool2D
\ingroup Interaction
\ingroup ToolManagerEtAl
Every tool is a mitk::StateMachine, which can follow any transition pattern that it likes. One important thing to know
is, that
every derived tool should always call SuperClass::Deactivated() at the end of its own implementation of Deactivated,
because mitk::Tool
resets the StateMachine in this method. Only if you are very sure that you covered all possible things that might
happen to your
own tool, you should consider not to reset the StateMachine from time to time.
To learn about the MITK implementation of state machines in general, have a look at \ref InteractionPage.
To derive a non-abstract tool, you inherit from mitk::Tool (or some other base class further down the inheritance
tree), and in your
own parameterless constructor (that is called from the itkFactorylessNewMacro that you use) you pass a StateMachine
pattern name to the superclass.
Names for valid patterns can be found in StateMachine.xml (which might be enhanced by you).
You have to implement at least GetXPM() and GetName() to provide some identification.
Each Tool knows its ToolManager, which can provide the data that the tool should work on.
\warning Only to be instantiated by mitk::ToolManager (because SetToolManager has to be called). All other uses are
unsupported.
$Author$
*/
class MITKSEGMENTATION_EXPORT Tool : public EventStateMachine, public InteractionEventObserver
{
public:
typedef mitk::Label::PixelType DefaultSegmentationDataType;
/**
* \brief To let GUI process new events (e.g. qApp->processEvents() )
*/
Message<> GUIProcessEventsMessage;
/**
* \brief To send error messages (to be shown by some GUI)
*/
Message1<std::string> ErrorMessage;
/**
* \brief To send whether the tool is busy (to be shown by some GUI)
*/
Message1<bool> CurrentlyBusy;
/**
* \brief To send general messages (to be shown by some GUI)
*/
Message1<std::string> GeneralMessage;
mitkClassMacro(Tool, EventStateMachine);
// no New(), there should only be subclasses
/**
\brief Returns an icon in the XPM format.
This icon has to fit into some kind of button in most applications, so make it smaller than 25x25 pixels.
XPM is e.g. supported by The Gimp. But if you open any XPM file in your text editor, you will see that you could
also "draw" it with an editor.
*/
virtual const char **GetXPM() const = 0;
/**
* \brief Returns the path of an icon.
*
* This icon is preferred to the XPM icon.
*/
virtual std::string GetIconPath() const { return ""; }
/**
* \brief Returns the path of a cursor icon.
*
*/
virtual us::ModuleResource GetCursorIconResource() const;
/**
* @brief Returns the tool button icon of the tool wrapped by a usModuleResource
* @return a valid ModuleResource or an invalid if this function
* is not reimplemented
*/
virtual us::ModuleResource GetIconResource() const;
/**
\brief Returns the name of this tool. Make it short!
This name has to fit into some kind of button in most applications, so take some time to think of a good name!
*/
virtual const char *GetName() const = 0;
/**
\brief Name of a group.
You can group several tools by assigning a group name. Graphical tool selectors might use this information to group
tools. (What other reason could there be?)
*/
virtual const char *GetGroup() const;
virtual void InitializeStateMachine();
/**
* \brief Interface for GUI creation.
*
* This is the basic interface for creation of a GUI object belonging to one tool.
*
* Tools that support a GUI (e.g. for display/editing of parameters) should follow some rules:
*
* - A Tool and its GUI are two separate classes
* - There may be several instances of a GUI at the same time.
* - mitk::Tool is toolkit (Qt, wxWidgets, etc.) independent, the GUI part is of course dependent
* - The GUI part inherits both from itk::Object and some GUI toolkit class
* - The GUI class name HAS to be constructed like "toolkitPrefix" tool->GetClassName() + "toolkitPostfix", e.g.
* MyTool -> wxMyToolGUI
* - For each supported toolkit there is a base class for tool GUIs, which contains some convenience methods
* - Tools notify the GUI about changes using ITK events. The GUI must observe interesting events.
* - The GUI base class may convert all ITK events to the GUI toolkit's favoured messaging system (Qt -> signals)
* - Calling methods of a tool by its GUI is done directly.
* In some cases GUIs don't want to be notified by the tool when they cause a change in a tool.
* There is a macro CALL_WITHOUT_NOTICE(method()), which will temporarily disable all notifications during a
* method call.
*/
virtual itk::Object::Pointer GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix);
virtual NodePredicateBase::ConstPointer GetReferenceDataPreference() const;
virtual NodePredicateBase::ConstPointer GetWorkingDataPreference() const;
DataNode::Pointer CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
const mitk::Color &color);
DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color);
- virtual bool CanHandle(BaseData *referenceData) const;
+ /** Function used to check if a tool can handle the referenceData and (if specified) the working data.
+ @pre referenceData must be a valid pointer
+ @param referenceData Pointer to the data that should be checked as valid reference for the tool.
+ @param workingData Pointer to the data that should be checked as valid working data for this tool.
+ This parameter can be null if no working data is specified so far.*/
+ virtual bool CanHandle(const BaseData *referenceData, const BaseData *workingData) const;
protected:
friend class ToolManager;
virtual void SetToolManager(ToolManager *);
void ConnectActionsAndFunctions() override;
/**
\brief Called when the tool gets activated.
Derived tools should call their parents implementation at the beginning of the overriding function.
*/
virtual void Activated();
/**
\brief Called when the tool gets deactivated.
Derived tools should call their parents implementation at the end of the overriding function.
*/
virtual void Deactivated();
/**
\brief Let subclasses change their event configuration.
*/
std::string m_EventConfig;
Tool(); // purposely hidden
Tool(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
~Tool() override;
void Notify(InteractionEvent *interactionEvent, bool isHandled) override;
bool FilterEvents(InteractionEvent *, DataNode *) override;
ToolManager *m_ToolManager;
private:
// for reference data
NodePredicateDataType::Pointer m_PredicateImages;
NodePredicateDimension::Pointer m_PredicateDim3;
NodePredicateDimension::Pointer m_PredicateDim4;
NodePredicateOr::Pointer m_PredicateDimension;
NodePredicateAnd::Pointer m_PredicateImage3D;
NodePredicateProperty::Pointer m_PredicateBinary;
NodePredicateNot::Pointer m_PredicateNotBinary;
NodePredicateProperty::Pointer m_PredicateSegmentation;
NodePredicateNot::Pointer m_PredicateNotSegmentation;
NodePredicateProperty::Pointer m_PredicateHelper;
NodePredicateNot::Pointer m_PredicateNotHelper;
NodePredicateAnd::Pointer m_PredicateImageColorful;
NodePredicateAnd::Pointer m_PredicateImageColorfulNotHelper;
NodePredicateAnd::Pointer m_PredicateReference;
// for working data
NodePredicateAnd::Pointer m_IsSegmentationPredicate;
std::string m_InteractorType;
std::map<us::ServiceReferenceU, EventConfig> m_DisplayInteractorConfigs;
const us::Module *m_InteractorModule;
};
} // namespace
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
index 2dcb1b21fe..720b82cb30 100755
--- a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
@@ -1,716 +1,722 @@
/*============================================================================
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.
============================================================================*/
//#define MBILOG_ENABLE_DEBUG 1
#include <QmitkStyleManager.h>
#include "QmitkToolSelectionBox.h"
#include "QmitkToolGUI.h"
#include "mitkBaseRenderer.h"
#include <QList>
#include <qapplication.h>
#include <qlayout.h>
#include <qmessagebox.h>
#include <qtoolbutton.h>
#include <qtooltip.h>
#include <queue>
#include "usModuleResource.h"
#include "usModuleResourceStream.h"
#include "mitkToolManagerProvider.h"
QmitkToolSelectionBox::QmitkToolSelectionBox(QWidget *parent, mitk::DataStorage *)
: QWidget(parent),
m_SelfCall(false),
m_DisplayedGroups("default"),
m_LayoutColumns(2),
m_ShowNames(true),
m_GenerateAccelerators(false),
m_ToolGUIWidget(nullptr),
m_LastToolGUI(nullptr),
m_ToolButtonGroup(nullptr),
m_ButtonLayout(nullptr),
m_EnabledMode(EnabledWithReferenceAndWorkingDataVisible)
{
QFont currentFont = QWidget::font();
currentFont.setBold(true);
QWidget::setFont(currentFont);
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
// muellerm
// QButtonGroup
m_ToolButtonGroup = new QButtonGroup(this);
// some features of QButtonGroup
m_ToolButtonGroup->setExclusive(false); // mutually exclusive toggle buttons
RecreateButtons();
QWidget::setContentsMargins(0, 0, 0, 0);
if (layout() != nullptr)
{
layout()->setContentsMargins(0, 0, 0, 0);
}
// reactions to signals
connect(m_ToolButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(toolButtonClicked(int)));
// reactions to ToolManager events
m_ToolManager->ActiveToolChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
// show active tool
SetOrUnsetButtonForActiveTool();
QWidget::setEnabled(false);
}
QmitkToolSelectionBox::~QmitkToolSelectionBox()
{
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
}
void QmitkToolSelectionBox::SetEnabledMode(EnabledMode mode)
{
m_EnabledMode = mode;
SetGUIEnabledAccordingToToolManagerState();
}
mitk::ToolManager *QmitkToolSelectionBox::GetToolManager()
{
return m_ToolManager;
}
void QmitkToolSelectionBox::SetToolManager(
mitk::ToolManager &newManager) // no nullptr pointer allowed here, a manager is required
{
// say bye to the old manager
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
if (QWidget::isEnabled())
{
m_ToolManager->UnregisterClient();
}
m_ToolManager = &newManager;
RecreateButtons();
// greet the new one
m_ToolManager->ActiveToolChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
if (QWidget::isEnabled())
{
m_ToolManager->RegisterClient();
}
// ask the new one what the situation is like
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::toolButtonClicked(int id)
{
if (!QWidget::isEnabled())
return; // this method could be triggered from the constructor, when we are still disabled
MITK_DEBUG << "toolButtonClicked(" << id << "): id translates to tool ID " << m_ToolIDForButtonID[id];
// QToolButton* toolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find(id) );
QToolButton *toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(id));
if (toolButton)
{
if ((m_ButtonIDForToolID.find(m_ToolManager->GetActiveToolID()) !=
m_ButtonIDForToolID.end()) // if we have this tool in our box
&&
(m_ButtonIDForToolID[m_ToolManager->GetActiveToolID()] ==
id)) // the tool corresponding to this button is already active
{
// disable this button, disable all tools
// mmueller
toolButton->setChecked(false);
m_ToolManager->ActivateTool(-1); // disable everything
}
else
{
// enable the corresponding tool
m_SelfCall = true;
m_ToolManager->ActivateTool(m_ToolIDForButtonID[id]);
m_SelfCall = false;
}
}
}
void QmitkToolSelectionBox::OnToolManagerToolModified()
{
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::SetOrUnsetButtonForActiveTool()
{
// we want to emit a signal in any case, whether we selected ourselves or somebody else changes "our" tool manager.
// --> emit before check on m_SelfCall
int id = m_ToolManager->GetActiveToolID();
// don't emit signal for shape model tools
bool emitSignal = true;
mitk::Tool *tool = m_ToolManager->GetActiveTool();
if (tool && std::string(tool->GetGroup()) == "organ_segmentation")
emitSignal = false;
if (emitSignal)
emit ToolSelected(id);
// delete old GUI (if any)
if (m_LastToolGUI && m_ToolGUIWidget)
{
if (m_ToolGUIWidget->layout())
{
m_ToolGUIWidget->layout()->removeWidget(m_LastToolGUI);
}
// m_LastToolGUI->reparent(nullptr, QPoint(0,0));
// TODO: reparent <-> setParent, Daniel fragen
m_LastToolGUI->setParent(nullptr);
delete m_LastToolGUI; // will hopefully notify parent and layouts
m_LastToolGUI = nullptr;
QLayout *layout = m_ToolGUIWidget->layout();
if (layout)
{
layout->activate();
}
}
QToolButton *toolButton(nullptr);
// mitk::Tool* tool = m_ToolManager->GetActiveTool();
if (m_ButtonIDForToolID.find(id) != m_ButtonIDForToolID.end()) // if this tool is in our box
{
// toolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find( m_ButtonIDForToolID[id] ) );
toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(m_ButtonIDForToolID[id]));
}
if (toolButton)
{
// mmueller
// uncheck all other buttons
QAbstractButton *tmpBtn = nullptr;
QList<QAbstractButton *>::iterator it;
for (int i = 0; i < m_ToolButtonGroup->buttons().size(); ++i)
{
tmpBtn = m_ToolButtonGroup->buttons().at(i);
if (tmpBtn != toolButton)
dynamic_cast<QToolButton *>(tmpBtn)->setChecked(false);
}
toolButton->setChecked(true);
if (m_ToolGUIWidget && tool)
{
// create and reparent new GUI (if any)
itk::Object::Pointer possibleGUI = tool->GetGUI("Qmitk", "GUI").GetPointer(); // prefix and postfix
if (possibleGUI.IsNull())
possibleGUI = tool->GetGUI("", "GUI").GetPointer();
QmitkToolGUI *gui = dynamic_cast<QmitkToolGUI *>(possibleGUI.GetPointer());
//!
m_LastToolGUI = gui;
if (gui)
{
gui->SetTool(tool);
// mmueller
// gui->reparent(m_ToolGUIWidget, gui->geometry().topLeft(), true );
gui->setParent(m_ToolGUIWidget);
gui->move(gui->geometry().topLeft());
gui->show();
QLayout *layout = m_ToolGUIWidget->layout();
if (!layout)
{
layout = new QVBoxLayout(m_ToolGUIWidget);
}
if (layout)
{
// mmueller
layout->addWidget(gui);
// layout->add( gui );
layout->activate();
}
}
}
}
else
{
// disable all buttons
QToolButton *selectedToolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->checkedButton());
// QToolButton* selectedToolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find( Q3ButtonGroup::selectedId() )
// );
if (selectedToolButton)
{
// mmueller
selectedToolButton->setChecked(false);
// selectedToolButton->setOn(false);
}
}
}
void QmitkToolSelectionBox::OnToolManagerReferenceDataModified()
{
if (m_SelfCall)
return;
MITK_DEBUG << "OnToolManagerReferenceDataModified()";
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::OnToolManagerWorkingDataModified()
{
if (m_SelfCall)
return;
MITK_DEBUG << "OnToolManagerWorkingDataModified()";
SetGUIEnabledAccordingToToolManagerState();
}
/**
Implementes the logic, which decides, when tools are activated/deactivated.
*/
void QmitkToolSelectionBox::SetGUIEnabledAccordingToToolManagerState()
{
mitk::DataNode *referenceNode = m_ToolManager->GetReferenceData(0);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
// MITK_DEBUG << this->name() << ": SetGUIEnabledAccordingToToolManagerState: referenceNode " << (void*)referenceNode
// << " workingNode " << (void*)workingNode << " isVisible() " << isVisible();
bool enabled = true;
switch (m_EnabledMode)
{
default:
case EnabledWithReferenceAndWorkingDataVisible:
enabled = referenceNode && workingNode &&
referenceNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"))) &&
workingNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"))) &&
isVisible();
break;
case EnabledWithReferenceData:
enabled = referenceNode && isVisible();
break;
case EnabledWithWorkingData:
enabled = workingNode && isVisible();
break;
case AlwaysEnabled:
enabled = isVisible();
break;
}
if (QWidget::isEnabled() == enabled)
return; // nothing to change
QWidget::setEnabled(enabled);
if (enabled)
{
m_ToolManager->RegisterClient();
int id = m_ToolManager->GetActiveToolID();
emit ToolSelected(id);
}
else
{
m_ToolManager->ActivateTool(-1);
m_ToolManager->UnregisterClient();
emit ToolSelected(-1);
}
}
/**
External enableization...
*/
void QmitkToolSelectionBox::setEnabled(bool /*enable*/)
{
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::RecreateButtons()
{
if (m_ToolManager.IsNull())
return;
/*
// remove all buttons that are there
QObjectList *l = Q3ButtonGroup::queryList( "QButton" );
QObjectListIt it( *l ); // iterate over all buttons
QObject *obj;
while ( (obj = it.current()) != 0 )
{
++it;
QButton* button = dynamic_cast<QButton*>(obj);
if (button)
{
Q3ButtonGroup::remove(button);
delete button;
}
}
delete l; // delete the list, not the objects
*/
// mmueller Qt impl
QList<QAbstractButton *> l = m_ToolButtonGroup->buttons();
// remove all buttons that are there
QList<QAbstractButton *>::iterator it;
QAbstractButton *btn;
for (it = l.begin(); it != l.end(); ++it)
{
btn = *it;
m_ToolButtonGroup->removeButton(btn);
// this->removeChild(btn);
delete btn;
}
// end mmueller Qt impl
mitk::ToolManager::ToolVectorTypeConst allPossibleTools = m_ToolManager->GetTools();
mitk::ToolManager::ToolVectorTypeConst allTools;
typedef std::pair<std::string::size_type, const mitk::Tool *> SortPairType;
typedef std::priority_queue<SortPairType> SortedToolQueueType;
SortedToolQueueType toolPositions;
// clear and sort all tools
// step one: find name/group of all tools in m_DisplayedGroups string. remember these positions for all tools.
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allPossibleTools.begin();
iter != allPossibleTools.end();
++iter)
{
const mitk::Tool *tool = *iter;
std::string::size_type namePos = m_DisplayedGroups.find(std::string("'") + tool->GetName() + "'");
std::string::size_type groupPos = m_DisplayedGroups.find(std::string("'") + tool->GetGroup() + "'");
if (!m_DisplayedGroups.empty() && namePos == std::string::npos && groupPos == std::string::npos)
continue; // skip
if (m_DisplayedGroups.empty() && std::string(tool->GetName()).length() > 0)
{
namePos = static_cast<std::string::size_type>(tool->GetName()[0]);
}
SortPairType thisPair = std::make_pair(namePos < groupPos ? namePos : groupPos, *iter);
toolPositions.push(thisPair);
}
// step two: sort tools according to previously found positions in m_DisplayedGroups
MITK_DEBUG << "Sorting order of tools (lower number --> earlier in button group)";
while (!toolPositions.empty())
{
SortPairType thisPair = toolPositions.top();
MITK_DEBUG << "Position " << thisPair.first << " : " << thisPair.second->GetName();
allTools.push_back(thisPair.second);
toolPositions.pop();
}
std::reverse(allTools.begin(), allTools.end());
MITK_DEBUG << "Sorted tools:";
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
{
MITK_DEBUG << (*iter)->GetName();
}
// try to change layout... bad?
// Q3GroupBox::setColumnLayout ( m_LayoutColumns, Qt::Horizontal );
// mmueller using gridlayout instead of Q3GroupBox
// this->setLayout(0);
if (m_ButtonLayout == nullptr)
m_ButtonLayout = new QGridLayout;
/*else
delete m_ButtonLayout;*/
int row(0);
int column(-1);
int currentButtonID(0);
m_ButtonIDForToolID.clear();
m_ToolIDForButtonID.clear();
QToolButton *button = nullptr;
MITK_DEBUG << "Creating buttons for tools";
// fill group box with buttons
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
{
const mitk::Tool *tool = *iter;
int currentToolID(m_ToolManager->GetToolID(tool));
++column;
// new line if we are at the maximum columns
if (column == m_LayoutColumns)
{
++row;
column = 0;
}
button = new QToolButton;
button->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
// add new button to the group
MITK_DEBUG << "Adding button with ID " << currentToolID;
m_ToolButtonGroup->addButton(button, currentButtonID);
// ... and to the layout
MITK_DEBUG << "Adding button in row/column " << row << "/" << column;
m_ButtonLayout->addWidget(button, row, column);
if (m_LayoutColumns == 1)
{
// button->setTextPosition( QToolButton::BesideIcon );
// mmueller
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
}
else
{
// button->setTextPosition( QToolButton::BelowIcon );
// mmueller
button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
}
// button->setToggleButton( true );
// mmueller
button->setCheckable(true);
if (currentToolID == m_ToolManager->GetActiveToolID())
button->setChecked(true);
QString label;
if (m_GenerateAccelerators)
{
label += "&";
}
label += tool->GetName();
QString tooltip = tool->GetName();
MITK_DEBUG << tool->GetName() << ", " << label.toLocal8Bit().constData() << ", '"
<< tooltip.toLocal8Bit().constData();
if (m_ShowNames)
{
/*
button->setUsesTextLabel(true);
button->setTextLabel( label ); // a label
QToolTip::add( button, tooltip );
*/
// mmueller Qt
button->setText(label); // a label
button->setToolTip(tooltip);
// mmueller
QFont currentFont = button->font();
currentFont.setBold(false);
button->setFont(currentFont);
}
us::ModuleResource iconResource = tool->GetIconResource();
if (!iconResource.IsValid())
{
button->setIcon(QIcon(QPixmap(tool->GetXPM())));
}
else
{
auto isSVG = "svg" == iconResource.GetSuffix();
auto openmode = isSVG ? std::ios_base::in : std::ios_base::binary;
us::ModuleResourceStream resourceStream(iconResource, openmode);
resourceStream.seekg(0, std::ios::end);
std::ios::pos_type length = resourceStream.tellg();
resourceStream.seekg(0, std::ios::beg);
char *data = new char[length];
resourceStream.read(data, length);
if (isSVG)
{
button->setIcon(QmitkStyleManager::ThemeIcon(QByteArray::fromRawData(data, length)));
}
else
{
QPixmap pixmap;
pixmap.loadFromData(QByteArray::fromRawData(data, length));
button->setIcon(QIcon(pixmap));
}
delete[] data;
if (m_ShowNames)
{
if (m_LayoutColumns == 1)
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
else
button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
button->setIconSize(QSize(24, 24));
}
else
{
button->setToolButtonStyle(Qt::ToolButtonIconOnly);
button->setIconSize(QSize(32, 32));
button->setToolTip(tooltip);
}
}
if (m_GenerateAccelerators)
{
QString firstLetter = QString(tool->GetName());
firstLetter.truncate(1);
button->setShortcut(
firstLetter); // a keyboard shortcut (just the first letter of the given name w/o any CTRL or something)
}
mitk::DataNode *dataNode = m_ToolManager->GetReferenceData(0);
+ const auto workingDataNode = m_ToolManager->GetWorkingData(0);
+ const mitk::BaseData* workingData = nullptr;
+ if (nullptr != workingDataNode)
+ {
+ workingData = workingDataNode->GetData();
+ }
- if (dataNode != nullptr && !tool->CanHandle(dataNode->GetData()))
+ if (dataNode != nullptr && !tool->CanHandle(dataNode->GetData(), workingData))
button->setEnabled(false);
m_ButtonIDForToolID[currentToolID] = currentButtonID;
m_ToolIDForButtonID[currentButtonID] = currentToolID;
MITK_DEBUG << "m_ButtonIDForToolID[" << currentToolID << "] == " << currentButtonID;
MITK_DEBUG << "m_ToolIDForButtonID[" << currentButtonID << "] == " << currentToolID;
tool->GUIProcessEventsMessage += mitk::MessageDelegate<QmitkToolSelectionBox>(
this, &QmitkToolSelectionBox::OnToolGUIProcessEventsMessage); // will never add a listener twice, so we don't have
// to check here
tool->ErrorMessage += mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(
this,
&QmitkToolSelectionBox::OnToolErrorMessage); // will never add a listener twice, so we don't have to check here
tool->GeneralMessage +=
mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(this, &QmitkToolSelectionBox::OnGeneralToolMessage);
++currentButtonID;
}
// setting grid layout for this groupbox
this->setLayout(m_ButtonLayout);
// this->update();
}
void QmitkToolSelectionBox::OnToolGUIProcessEventsMessage()
{
qApp->processEvents();
}
void QmitkToolSelectionBox::OnToolErrorMessage(std::string s)
{
QMessageBox::critical(
this, "MITK", QString(s.c_str()), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::OnGeneralToolMessage(std::string s)
{
QMessageBox::information(
this, "MITK", QString(s.c_str()), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::SetDisplayedToolGroups(const std::string &toolGroups)
{
if (m_DisplayedGroups != toolGroups)
{
QString q_DisplayedGroups = toolGroups.c_str();
// quote all unquoted single words
q_DisplayedGroups = q_DisplayedGroups.replace(QRegExp("\\b(\\w+)\\b|'([^']+)'"), "'\\1\\2'");
MITK_DEBUG << "m_DisplayedGroups was \"" << toolGroups << "\"";
m_DisplayedGroups = q_DisplayedGroups.toLocal8Bit().constData();
MITK_DEBUG << "m_DisplayedGroups is \"" << m_DisplayedGroups << "\"";
RecreateButtons();
SetOrUnsetButtonForActiveTool();
}
}
void QmitkToolSelectionBox::SetLayoutColumns(int columns)
{
if (columns > 0 && columns != m_LayoutColumns)
{
m_LayoutColumns = columns;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetShowNames(bool show)
{
if (show != m_ShowNames)
{
m_ShowNames = show;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetGenerateAccelerators(bool accel)
{
if (accel != m_GenerateAccelerators)
{
m_GenerateAccelerators = accel;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetToolGUIArea(QWidget *parentWidget)
{
m_ToolGUIWidget = parentWidget;
}
void QmitkToolSelectionBox::setTitle(const QString & /*title*/)
{
}
void QmitkToolSelectionBox::showEvent(QShowEvent *e)
{
QWidget::showEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::hideEvent(QHideEvent *e)
{
QWidget::hideEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}