diff --git a/Modules/Multilabel/mitkLabelSet.cpp b/Modules/Multilabel/mitkLabelSet.cpp
index 43bd03d187..9694021070 100644
--- a/Modules/Multilabel/mitkLabelSet.cpp
+++ b/Modules/Multilabel/mitkLabelSet.cpp
@@ -1,361 +1,361 @@
/*============================================================================
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 "mitkLabelSet.h"
#include "mitkDICOMSegmentationPropertyHelper.h"
#include <itkCommand.h>
mitk::LabelSet::LabelSet() : m_ActiveLabelValue(0), m_Layer(0)
{
m_LookupTable = mitk::LookupTable::New();
m_LookupTable->SetType(mitk::LookupTable::MULTILABEL);
m_ReservedLabelValuesFunctor = [this]() {
std::vector<LabelValueType> result = { 0 };
for (auto [value, label] : this->m_LabelContainer)
{
result.emplace_back(value);
}
return result;
};
}
mitk::LabelSet::~LabelSet()
{
m_LabelContainer.clear();
}
mitk::LabelSet::LabelSet(const LabelSet &other)
: itk::Object(),
m_LookupTable(other.GetLookupTable()->Clone()),
m_ActiveLabelValue(other.GetActiveLabel()->GetValue()),
m_Layer(other.GetLayer())
{
// clone Labels
auto otherIt = other.IteratorConstBegin();
for (; otherIt != other.IteratorConstEnd(); ++otherIt)
{
m_LabelContainer[otherIt->first] = otherIt->second->Clone();
itk::MemberCommand<LabelSet>::Pointer command = itk::MemberCommand<LabelSet>::New();
command->SetCallbackFunction(this, &LabelSet::OnLabelModified);
m_LabelContainer[otherIt->first]->AddObserver(itk::ModifiedEvent(), command);
}
m_ReservedLabelValuesFunctor = other.m_ReservedLabelValuesFunctor;
}
void mitk::LabelSet::OnLabelModified(const Object* sender, const itk::EventObject&)
{
auto label = dynamic_cast<const Label*>(sender);
if (nullptr == label) mitkThrow() << "LabelSet is in wrong state. LabelModified event is not send by a label instance.";
ModifyLabelEvent.Send(label->GetValue());
Superclass::Modified();
}
mitk::LabelSet::LabelContainerConstIteratorType mitk::LabelSet::IteratorConstEnd() const
{
return m_LabelContainer.end();
}
mitk::LabelSet::LabelContainerConstIteratorType mitk::LabelSet::IteratorConstBegin() const
{
return m_LabelContainer.begin();
}
mitk::LabelSet::LabelContainerIteratorType mitk::LabelSet::IteratorEnd()
{
return m_LabelContainer.end();
}
mitk::LabelSet::LabelContainerIteratorType mitk::LabelSet::IteratorBegin()
{
return m_LabelContainer.begin();
}
unsigned int mitk::LabelSet::GetNumberOfLabels() const
{
return m_LabelContainer.size();
}
void mitk::LabelSet::SetLayer(unsigned int layer)
{
m_Layer = layer;
Modified();
}
void mitk::LabelSet::SetActiveLabel(PixelType pixelValue)
{
m_ActiveLabelValue = pixelValue;
ActiveLabelEvent.Send(pixelValue);
Modified();
}
bool mitk::LabelSet::ExistLabel(PixelType pixelValue)
{
return m_LabelContainer.count(pixelValue) > 0 ? true : false;
}
void mitk::LabelSet::AddLabel(mitk::Label *label, bool addAsClone)
{
unsigned int max_size = mitk::Label::MAX_LABEL_VALUE + 1;
if (m_LabelContainer.size() >= max_size)
return;
- mitk::Label::Pointer newLabel = addAsClone ? label->Clone() : label;
+ mitk::Label::Pointer newLabel = addAsClone ? label->Clone() : Label::Pointer(label);
// TODO use layer of label parameter
newLabel->SetLayer(m_Layer);
PixelType pixelValue = newLabel->GetValue();
if (!m_LabelContainer.empty())
{
auto usedValues = m_ReservedLabelValuesFunctor();
auto finding = std::find(usedValues.begin(), usedValues.end(), pixelValue);
if (!usedValues.empty() && usedValues.end() != finding)
{
pixelValue = usedValues.back()+1;
MITK_DEBUG << "LabelSet label collision. Tried to add a label with a value already in use. Value will be adapted. Old value: " << newLabel->GetValue() << "; new value: " << pixelValue;
newLabel->SetValue(pixelValue);
}
}
// new map entry
m_LabelContainer[pixelValue] = newLabel;
UpdateLookupTable(pixelValue);
// add DICOM information of the label
DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(newLabel);
itk::MemberCommand<LabelSet>::Pointer command = itk::MemberCommand<LabelSet>::New();
command->SetCallbackFunction(this, &LabelSet::OnLabelModified);
newLabel->AddObserver(itk::ModifiedEvent(), command);
SetActiveLabel(newLabel->GetValue());
AddLabelEvent.Send(newLabel->GetValue());
Modified();
}
void mitk::LabelSet::AddLabel(const std::string &name, const mitk::Color &color)
{
mitk::Label::Pointer newLabel = mitk::Label::New();
newLabel->SetName(name);
newLabel->SetColor(color);
AddLabel(newLabel);
}
void mitk::LabelSet::RenameLabel(PixelType pixelValue, const std::string &name, const mitk::Color &color)
{
mitk::Label *label = GetLabel(pixelValue);
label->SetName(name);
label->SetColor(color);
// change DICOM information of the label
DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(label);
}
void mitk::LabelSet::SetLookupTable(mitk::LookupTable *lut)
{
m_LookupTable = lut;
Modified();
}
void mitk::LabelSet::PrintSelf(std::ostream & /*os*/, itk::Indent /*indent*/) const
{
}
void mitk::LabelSet::RemoveLabel(PixelType pixelValue)
{
auto it = m_LabelContainer.rbegin();
PixelType nextActivePixelValue = it->first;
for (; it != m_LabelContainer.rend(); ++it)
{
if (it->first == pixelValue)
{
it->second->RemoveAllObservers();
m_LabelContainer.erase(pixelValue);
break;
}
nextActivePixelValue = it->first;
}
if (m_ActiveLabelValue == pixelValue)
{
if (ExistLabel(nextActivePixelValue))
SetActiveLabel(nextActivePixelValue);
else
SetActiveLabel(m_LabelContainer.rbegin()->first);
}
RemoveLabelEvent.Send(pixelValue);
Modified();
}
void mitk::LabelSet::RemoveAllLabels()
{
auto _it = IteratorBegin();
for (; _it != IteratorConstEnd();)
{
auto labelValue = _it->first;
m_LabelContainer.erase(_it++);
RemoveLabelEvent.Send(labelValue);
}
AllLabelsModifiedEvent.Send();
}
void mitk::LabelSet::SetNextActiveLabel()
{
auto it = m_LabelContainer.find(m_ActiveLabelValue);
if (it != m_LabelContainer.end())
++it;
if (it == m_LabelContainer.end())
{
it = m_LabelContainer.begin();
if (m_LabelContainer.size() > 1)
++it; // ...skip background label!
}
SetActiveLabel(it->first);
}
void mitk::LabelSet::SetAllLabelsLocked(bool value)
{
auto _end = m_LabelContainer.end();
auto _it = m_LabelContainer.begin();
for (; _it != _end; ++_it)
_it->second->SetLocked(value);
AllLabelsModifiedEvent.Send();
Modified();
}
void mitk::LabelSet::SetAllLabelsVisible(bool value)
{
auto _end = m_LabelContainer.end();
auto _it = m_LabelContainer.begin();
for (; _it != _end; ++_it)
{
_it->second->SetVisible(value);
UpdateLookupTable(_it->first);
}
AllLabelsModifiedEvent.Send();
Modified();
}
void mitk::LabelSet::UpdateLookupTable(PixelType pixelValue)
{
const mitk::Color &color = GetLabel(pixelValue)->GetColor();
double rgba[4];
m_LookupTable->GetTableValue(static_cast<int>(pixelValue), rgba);
rgba[0] = color.GetRed();
rgba[1] = color.GetGreen();
rgba[2] = color.GetBlue();
if (GetLabel(pixelValue)->GetVisible())
rgba[3] = GetLabel(pixelValue)->GetOpacity();
else
rgba[3] = 0.0;
m_LookupTable->SetTableValue(static_cast<int>(pixelValue), rgba);
}
mitk::Label *mitk::LabelSet::GetLabel(PixelType pixelValue)
{
if (m_LabelContainer.find(pixelValue) == m_LabelContainer.end())
return nullptr;
return m_LabelContainer[pixelValue];
}
const mitk::Label *mitk::LabelSet::GetLabel(PixelType pixelValue) const
{
auto it = m_LabelContainer.find(pixelValue);
if (it == m_LabelContainer.end())
return nullptr;
return it->second.GetPointer();
}
bool mitk::Equal(const mitk::LabelSet &leftHandSide, const mitk::LabelSet &rightHandSide, ScalarType eps, bool verbose)
{
bool returnValue = true;
// LabelSetmembers
MITK_INFO(verbose) << "--- LabelSet Equal ---";
// m_LookupTable;
const mitk::LookupTable *lhsLUT = leftHandSide.GetLookupTable();
const mitk::LookupTable *rhsLUT = rightHandSide.GetLookupTable();
returnValue = *lhsLUT == *rhsLUT;
if (!returnValue)
{
MITK_INFO(verbose) << "Lookup tabels not equal.";
return returnValue;
;
}
// m_ActiveLabel;
returnValue = mitk::Equal(*leftHandSide.GetActiveLabel(), *rightHandSide.GetActiveLabel(), eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Active label not equal.";
return returnValue;
;
}
// m_Layer;
returnValue = leftHandSide.GetLayer() == rightHandSide.GetLayer();
if (!returnValue)
{
MITK_INFO(verbose) << "Layer index not equal.";
return returnValue;
;
}
// container size;
returnValue = leftHandSide.GetNumberOfLabels() == rightHandSide.GetNumberOfLabels();
if (!returnValue)
{
MITK_INFO(verbose) << "Number of labels not equal.";
return returnValue;
;
}
// Label container (map)
// m_LabelContainer;
auto lhsit = leftHandSide.IteratorConstBegin();
auto rhsit = rightHandSide.IteratorConstBegin();
for (; lhsit != leftHandSide.IteratorConstEnd(); ++lhsit, ++rhsit)
{
returnValue = rhsit->first == lhsit->first;
if (!returnValue)
{
MITK_INFO(verbose) << "Label in label container not equal.";
return returnValue;
;
}
returnValue = mitk::Equal(*(rhsit->second), *(lhsit->second), eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Label in label container not equal.";
return returnValue;
;
}
}
return returnValue;
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.h b/Modules/Segmentation/Interactions/mitkTool.h
index d22bac9d2b..662c9b64c8 100644
--- a/Modules/Segmentation/Interactions/mitkTool.h
+++ b/Modules/Segmentation/Interactions/mitkTool.h
@@ -1,273 +1,273 @@
/*============================================================================
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
#define mitkTool_h
#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::EventStateMachine, which can follow any transition pattern that it likes.
Every derived tool should always call SuperClass::Deactivated() at the end of its own implementation of Deactivated,
because mitk::Tool resets the interaction configuration 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 configuration.
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 state machine name (interactor type).
Names and .xml-files for valid state machines can be found in different "Interaction" directories (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.
*/
//[[deprecated]]
- DEPRECATED(virtual const char **GetXPM() const = 0);
+ DEPRECATED(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) const;
DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color) 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 *);
/** Returns the pointer to the tool manager of the tool. May be null.*/
ToolManager* GetToolManager() const;
/** Returns the data storage provided by the toolmanager. May be null (e.g. if
ToolManager is not set).*/
mitk::DataStorage* GetDataStorage() const;
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(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
~Tool() override;
void Notify(InteractionEvent *interactionEvent, bool isHandled) override;
bool FilterEvents(InteractionEvent *, DataNode *) override;
private:
ToolManager* m_ToolManager;
// 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_DisplayInteractionConfigs;
const us::Module *m_InteractorModule;
};
} // namespace
#endif