diff --git a/Modules/Core/include/mitkBaseProperty.h b/Modules/Core/include/mitkBaseProperty.h
index 05a305dc50..a0f02b6da6 100644
--- a/Modules/Core/include/mitkBaseProperty.h
+++ b/Modules/Core/include/mitkBaseProperty.h
@@ -1,98 +1,102 @@
/*============================================================================
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 mitkBaseProperty_h
#define mitkBaseProperty_h
#include <MitkCoreExports.h>
#include <itkObjectFactory.h>
#include <mitkCommon.h>
#include <string>
+#include <nlohmann/json.hpp>
namespace mitk
{
/*! \brief Abstract base class for properties
\ingroup DataManagement
Base class for properties. Properties are arbitrary additional information
(to define a new type of information you have to define a subclass of
BaseProperty) that can be added to a PropertyList.
Concrete subclasses of BaseProperty should define Set-/Get-methods to assess
the property value, which should be stored by value (not by reference).
Subclasses must implement an operator==(const BaseProperty& property), which
is used by PropertyList to check whether a property has been changed.
*/
class MITKCORE_EXPORT BaseProperty : public itk::Object
{
public:
mitkClassMacroItkParent(BaseProperty, itk::Object);
itkCloneMacro(Self);
/*! @brief Subclasses must implement IsEqual(const BaseProperty&) to support comparison.
operator== which is used by PropertyList to check whether a property has been changed.
*/
bool
operator==(const BaseProperty &property) const;
/*! @brief Assigns property to this BaseProperty instance.
Subclasses must implement Assign(const BaseProperty&) and call the superclass
Assign method for proper handling of polymorphic assignments. The assignment
operator of the subclass should be disabled and the baseclass operator should
be made visible using "using" statements.
*/
BaseProperty &operator=(const BaseProperty &property);
/*! @brief Assigns property to this BaseProperty instance.
This method is identical to the assignment operator, except for the return type.
It allows to directly check if the assignment was successful.
*/
bool AssignProperty(const BaseProperty &property);
virtual std::string GetValueAsString() const;
+ virtual void ToJSON(nlohmann::json& j) const = 0;
+ virtual void FromJSON(const nlohmann::json& j) = 0;
+
/**
* @brief Default return value if a property which can not be returned as string
*/
static const std::string VALUE_CANNOT_BE_CONVERTED_TO_STRING;
protected:
BaseProperty();
BaseProperty(const BaseProperty &other);
~BaseProperty() override;
private:
/*!
Override this method in subclasses to implement a meaningful comparison. The property
argument is guaranteed to be castable to the type of the implementing subclass.
*/
virtual bool IsEqual(const BaseProperty &property) const = 0;
/*!
Override this method in subclasses to implement a meaningful assignment. The property
argument is guaranteed to be castable to the type of the implementing subclass.
@warning This is not yet exception aware/safe and if this method returns false,
this property's state might be undefined.
@return True if the argument could be assigned to this property.
*/
virtual bool Assign(const BaseProperty &) = 0;
};
} // namespace mitk
#endif
diff --git a/Modules/Core/include/mitkColorProperty.h b/Modules/Core/include/mitkColorProperty.h
index 0b1809c0fb..a90567c2b1 100644
--- a/Modules/Core/include/mitkColorProperty.h
+++ b/Modules/Core/include/mitkColorProperty.h
@@ -1,96 +1,118 @@
/*============================================================================
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 mitkColorProperty_h
#define mitkColorProperty_h
#include "mitkBaseProperty.h"
#include <MitkCoreExports.h>
#include <itkRGBPixel.h>
namespace mitk
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4522)
#endif
/**
* @brief Color Standard RGB color typedef (float)
*
* Standard RGB color typedef to get rid of template argument (float).
* Color range is from 0.0f to 1.0f for each component.
*
* @ingroup Property
*/
typedef itk::RGBPixel<float> Color;
/**
* @brief The ColorProperty class RGB color property
* @ingroup DataManagement
*
* @note If you want to apply the mitk::ColorProperty to an mitk::Image
* make sure to set the mitk::RenderingModeProperty to a mode which
* supports color (e.g. LEVELWINDOW_COLOR). For an example how to use
* the mitk::ColorProperty see mitkImageVtkMapper2DColorTest.cpp in
* Core/Code/Rendering.
*/
class MITKCORE_EXPORT ColorProperty : public BaseProperty
{
protected:
mitk::Color m_Color;
ColorProperty();
ColorProperty(const ColorProperty &other);
ColorProperty(const float red, const float green, const float blue);
ColorProperty(const float color[3]);
ColorProperty(const mitk::Color &color);
public:
mitkClassMacro(ColorProperty, BaseProperty);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self) mitkNewMacro1Param(ColorProperty, const float *);
mitkNewMacro1Param(ColorProperty, const mitk::Color &);
mitkNewMacro3Param(ColorProperty, const float, const float, const float);
typedef mitk::Color ValueType;
const mitk::Color &GetColor() const;
const mitk::Color &GetValue() const;
std::string GetValueAsString() const override;
void SetColor(const mitk::Color &color);
void SetValue(const mitk::Color &color);
void SetColor(float red, float green, float blue);
+ void ToJSON(nlohmann::json &j) const override;
+ void FromJSON(const nlohmann::json &j) override;
+
using BaseProperty::operator=;
private:
// purposely not implemented
ColorProperty &operator=(const ColorProperty &);
itk::LightObject::Pointer InternalClone() const override;
bool IsEqual(const BaseProperty &property) const override;
bool Assign(const BaseProperty &property) override;
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace mitk
+namespace itk
+{
+ template <typename TComponent>
+ void to_json(nlohmann::json& j, const RGBPixel<TComponent>& c)
+ {
+ j = nlohmann::json::array();
+
+ for (size_t i = 0; i < 3; ++i)
+ j.push_back(c[i]);
+ }
+
+ template <typename TComponent>
+ void from_json(const nlohmann::json& j, RGBPixel<TComponent>& c)
+ {
+ for (size_t i = 0; i < 3; ++i)
+ j.at(i).get_to(c[i]);
+ }
+} // namespace itk
+
#endif
diff --git a/Modules/Core/include/mitkEnumerationProperty.h b/Modules/Core/include/mitkEnumerationProperty.h
index 251f1cce82..3d5b827542 100644
--- a/Modules/Core/include/mitkEnumerationProperty.h
+++ b/Modules/Core/include/mitkEnumerationProperty.h
@@ -1,198 +1,197 @@
/*============================================================================
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 mitkEnumerationProperty_h
#define mitkEnumerationProperty_h
#include <mitkBaseProperty.h>
#include <map>
#include <string>
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522) // "multiple assignment operators specified"
#endif
namespace mitk
{
/**
* This class may be used to store properties similar to enumeration values.
* Each enumeration value is identified by an id and a name. Note that both
* name and id must be unique. Add enumeration values before you use the
* Get/SetValue methods.
*
* To use this class, create a subclass that adds the possible enumeration
* values in its constructor. You should override AddEnum() as protected so
* that the user isn't able to add invalid enumeration values.
*
* As example see mitk::VtkRepresentationProperty or
* mitk::VtkInterpolationProperty.
*
* @ingroup DataManagement
*/
class MITKCORE_EXPORT EnumerationProperty : public BaseProperty
{
public:
mitkClassMacro(EnumerationProperty, BaseProperty);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/**
* Represents the unique id which is assigned to each enumeration name.
*/
typedef unsigned int IdType;
/**
* Type used to store a mapping from enumeration id to enumeration name.
*/
typedef std::map<IdType, std::string> EnumIdsContainerType;
/**
* Type used to store a mapping from enumeration name to enumeration id.
*/
typedef std::map<std::string, IdType> EnumStringsContainerType;
/**
* Type used for iterators over all defined enumeration values.
*/
typedef EnumIdsContainerType::const_iterator EnumConstIterator;
/**
* Adds an enumeration value into the enumeration. The name and id provided
* must be unique. This is checked while adding the new enumeration value.
* If it is not unique, false is returned. If addition was successful, true
* is returned.
* @param name The unique name of the enumeration value
* @param id The unique id of the enumeration value
* @returns True, if the name/id combination was successfully added to the
* enumeration values. Otherwise false.
*/
virtual bool AddEnum(const std::string &name, const IdType &id);
/**
* Sets the current value of the enumeration.
* @param name The name of the enumeration value to set
* @returns True if the value was successfully set. Otherwise false.
*/
virtual bool SetValue(const std::string &name);
/**
* Sets the current value of the enumeration.
* @param id The id of the enumeration value to set
* @returns True, if the value was successfully set. Otherwise false.
*/
virtual bool SetValue(const IdType &id);
/**
* Returns the id of the current enumeration value. If it was not set so far,
* the return value is unspecified.
*/
virtual IdType GetValueAsId() const;
/**
* Returns the name of the current enumeration value. If it was not set so far,
* the return value is unspecified.
*/
std::string GetValueAsString() const override;
/**
* Clears all enumerations including the current one.
*/
virtual void Clear();
/**
* Determines the number of enumeration values.
*/
virtual EnumIdsContainerType::size_type Size() const;
/**
* Provides access to the set of enumeration values. The name can be
* accessed with iterator->second, the id via iterator->first.
* @returns An iterator over all enumeration values.
*/
virtual EnumConstIterator Begin() const;
/**
* Specifies the end of the range of enumeration values.
* @returns An iterator pointing past the last enumeration values.
*/
virtual EnumConstIterator End() const;
/**
* Returns the name for the given id.
* @param id The id for which the name should be determined.
* If the id is invalid, the return value is unspecified.
* @returns The name of the determined enumeration value.
*/
virtual std::string GetEnumString(const IdType &id) const;
/**
* Returns the id for the given name.
* @param name The enumeration name for which the id should be determined.
* If the name is invalid, the return value is unspecified.
* @returns The id of the determined enumeration value.
*/
virtual IdType GetEnumId(const std::string &name) const;
/**
* Determines if a given id is valid.
* @param id The id to check
* @returns True if the given id is valid. Otherwise false.
*/
virtual bool IsValidEnumerationValue(const IdType &id) const;
/**
* Determines if a given name is valid.
* @param name The name to check
* @returns True if the given name is valid. Otherwise false.
*/
virtual bool IsValidEnumerationValue(const std::string &name) const;
const EnumIdsContainerType &GetEnumIds() const;
const EnumStringsContainerType &GetEnumStrings() const;
EnumIdsContainerType &GetEnumIds();
EnumStringsContainerType &GetEnumStrings();
+ void ToJSON(nlohmann::json& j) const override;
+ void FromJSON(const nlohmann::json& j) override;
+
using BaseProperty::operator=;
EnumerationProperty & operator=(const EnumerationProperty &) = delete;
protected:
/**
* Default constructor. The current value of the enumeration is undefined.
*/
EnumerationProperty();
EnumerationProperty(const EnumerationProperty &);
bool IsEqual(const BaseProperty &property) const override;
bool Assign(const BaseProperty &property) override;
mitkCloneMacro(Self);
private:
IdType m_CurrentValue;
-
- typedef std::map<std::string, EnumIdsContainerType> IdMapForClassNameContainerType;
- typedef std::map<std::string, EnumStringsContainerType> StringMapForClassNameContainerType;
-
EnumIdsContainerType m_IdMap;
EnumStringsContainerType m_NameMap;
};
}
#ifdef _MSC_VER
# pragma warning(pop)
#endif
#endif
diff --git a/Modules/Core/include/mitkGenericLookupTable.h b/Modules/Core/include/mitkGenericLookupTable.h
index c0ad940072..43131a32cc 100644
--- a/Modules/Core/include/mitkGenericLookupTable.h
+++ b/Modules/Core/include/mitkGenericLookupTable.h
@@ -1,138 +1,156 @@
/*============================================================================
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 mitkGenericLookupTable_h
#define mitkGenericLookupTable_h
#include <map>
#include <sstream>
#include <cstdlib>
#include <string>
#include <itkDataObject.h>
#include "mitkNumericTypes.h"
#include <MitkCoreExports.h>
+#include <nlohmann/json.hpp>
+
namespace mitk
{
/**
* @brief Template class for generating lookup-tables
*
* This class template can be instantiated for all classes/internal types that fulfills
* these requirements:
* - an operator<< so that the properties value can be put into a std::stringstream
* - an operator== so that two properties can be checked for equality
*
* The main purpose of this class is to be used in conjunction with
* GenericLookupTableProperty. This enables passing of arbitrary lookup
* tables to mappers to configure the rendering process.
*/
template <typename T>
class GenericLookupTable
{
public:
typedef unsigned int IdentifierType;
typedef T ValueType;
typedef std::map<IdentifierType, ValueType> LookupTableType;
typedef GenericLookupTable Self;
GenericLookupTable() {}
virtual ~GenericLookupTable() {}
virtual const char *GetNameOfClass() const { return "GenericLookupTable"; }
void SetTableValue(IdentifierType id, ValueType value) { m_LookupTable[id] = value; }
bool ValueExists(IdentifierType id) const
{
auto it = m_LookupTable.find(id);
return (it != m_LookupTable.end());
}
ValueType GetTableValue(IdentifierType id) const
{
auto it = m_LookupTable.find(id);
if (it != m_LookupTable.end())
return it->second;
else
throw std::range_error("id does not exist in the lookup table");
}
const LookupTableType &GetLookupTable() const { return m_LookupTable; }
bool operator==(const Self &lookupTable) const { return (m_LookupTable == lookupTable.m_LookupTable); }
bool operator!=(const Self &lookupTable) const { return !(m_LookupTable == lookupTable.m_LookupTable); }
virtual Self &operator=(const Self &other) // \TODO: this needs to be unit tested!
{
if (this == &other)
{
return *this;
}
else
{
m_LookupTable.clear();
m_LookupTable = other.m_LookupTable;
return *this;
}
}
+ template<typename T>
+ friend void from_json(const nlohmann::json&, GenericLookupTable<T>&);
+
protected:
LookupTableType m_LookupTable;
};
+
+ template <typename T>
+ void to_json(nlohmann::json& j, const GenericLookupTable<T>& t)
+ {
+ j = t.GetLookupTable();
+ }
+
+ template <typename T>
+ void from_json(const nlohmann::json& j, GenericLookupTable<T>& t)
+ {
+ j.get_to(t.m_LookupTable);
+ }
+
} // namespace mitk
/**
* Generates a specialized subclass of mitk::GenericLookupTable.
* This way, GetNameOfClass() returns the value provided by LookupTableName.
* Please see mitkProperties.h for examples.
* @param LookupTableName the name of the instantiation of GenericLookupTable
* @param Type the value type of the GenericLookupTable
*/
#define mitkSpecializeGenericLookupTable(LookupTableName, Type) \
\
class MITKCORE_EXPORT LookupTableName : public GenericLookupTable<Type> \
\
{ \
public: \
typedef LookupTableName Self; \
typedef GenericLookupTable<Type> Superclass; \
virtual const char *GetNameOfClass() const { return #LookupTableName; } \
LookupTableName() {} \
virtual Superclass &operator=(const Superclass &other) { return Superclass::operator=(other); } \
virtual ~LookupTableName() {} \
}; \
\
MITKCORE_EXPORT std::ostream &operator<<(std::ostream &stream, const LookupTableName & /*l*/);
/**
* Generates the ostream << operator for the lookuptable. This definition
* of a global function must be in a cpp file, therefore it is split from the
* class declaration macro mitkSpecializeGenericLookupTable.
*/
#define mitkSpecializeGenericLookupTableOperator(LookupTableName) \
\
std::ostream &mitk::operator<<(std::ostream &stream, const LookupTableName &l) \
\
{ \
typedef LookupTableName::LookupTableType::const_iterator IterType; \
IterType e = l.GetLookupTable().end(); \
IterType b = l.GetLookupTable().begin(); \
stream << "["; \
for (IterType i = b; i != e; ++i) \
{ \
if (i != b) \
{ \
stream << ", "; \
} \
stream << i->first << " -> " << i->second; \
} \
return stream << "]"; \
};
#endif
diff --git a/Modules/Core/include/mitkGenericProperty.h b/Modules/Core/include/mitkGenericProperty.h
index ceff2ad5e2..dad7c897da 100644
--- a/Modules/Core/include/mitkGenericProperty.h
+++ b/Modules/Core/include/mitkGenericProperty.h
@@ -1,142 +1,152 @@
/*============================================================================
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 mitkGenericProperty_h
#define mitkGenericProperty_h
#include <sstream>
#include <cstdlib>
#include <string>
#include "mitkBaseProperty.h"
#include "mitkNumericTypes.h"
#include <MitkCoreExports.h>
namespace mitk
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4522)
#endif
/*!
@ brief Template class for generating properties for int, float, bool, etc.
This class template can be instantiated for all classes/internal types that fulfills
these requirements:
- an operator<< so that the properties value can be put into a std::stringstream
- an operator== so that two properties can be checked for equality
Note: you must use the macro mitkSpecializeGenericProperty to provide specializations
for concrete types (e.g. BoolProperty). Please see mitkProperties.h for examples. If you
don't use the mitkSpecializeGenericProperty Macro, GetNameOfClass() returns a wrong name.
*/
template <typename T>
class MITK_EXPORT GenericProperty : public BaseProperty
{
public:
mitkClassMacro(GenericProperty, BaseProperty);
mitkNewMacro1Param(GenericProperty<T>, T);
itkCloneMacro(Self);
typedef T ValueType;
itkSetMacro(Value, T);
itkGetConstMacro(Value, T);
std::string GetValueAsString() const override
{
std::stringstream myStr;
myStr << GetValue();
return myStr.str();
}
+ void ToJSON(nlohmann::json& j) const override
+ {
+ j = this->GetValue();
+ }
+
+ void FromJSON(const nlohmann::json& j) override
+ {
+ this->SetValue(j.get<T>());
+ }
+
using BaseProperty::operator=;
protected:
GenericProperty() {}
GenericProperty(T x) : m_Value(x) {}
GenericProperty(const GenericProperty &other) : BaseProperty(other), m_Value(other.m_Value) {}
T m_Value;
private:
// purposely not implemented
GenericProperty &operator=(const GenericProperty &);
itk::LightObject::Pointer InternalClone() const override
{
itk::LightObject::Pointer result(new Self(*this));
result->UnRegister();
return result;
}
bool IsEqual(const BaseProperty &other) const override
{
return (this->m_Value == static_cast<const Self &>(other).m_Value);
}
bool Assign(const BaseProperty &other) override
{
this->m_Value = static_cast<const Self &>(other).m_Value;
return true;
}
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace mitk
/**
* Generates a specialized subclass of mitk::GenericProperty.
* This way, GetNameOfClass() returns the value provided by PropertyName.
* Please see mitkProperties.h for examples.
* @param PropertyName the name of the subclass of GenericProperty
* @param Type the value type of the GenericProperty
* @param Export the export macro for DLL usage
*/
#define mitkDeclareGenericProperty(PropertyName, Type, Export) \
\
class Export PropertyName : public GenericProperty<Type> \
\
{ \
public: \
mitkClassMacro(PropertyName, GenericProperty<Type>); \
itkFactorylessNewMacro(Self); \
itkCloneMacro(Self); \
mitkNewMacro1Param(PropertyName, Type); \
\
using BaseProperty::operator=; \
\
protected: \
PropertyName(); \
PropertyName(const PropertyName &); \
PropertyName(Type x); \
\
private: \
itk::LightObject::Pointer InternalClone() const override; \
};
#define mitkDefineGenericProperty(PropertyName, Type, DefaultValue) \
mitk::PropertyName::PropertyName() : Superclass(DefaultValue) {} \
mitk::PropertyName::PropertyName(const PropertyName &other) : GenericProperty<Type>(other) {} \
mitk::PropertyName::PropertyName(Type x) : Superclass(x) {} \
itk::LightObject::Pointer mitk::PropertyName::InternalClone() const \
{ \
itk::LightObject::Pointer result(new Self(*this)); \
result->UnRegister(); \
return result; \
}
#endif
diff --git a/Modules/Core/include/mitkLookupTableProperty.h b/Modules/Core/include/mitkLookupTableProperty.h
index 8a57cc0e83..f753b288b3 100644
--- a/Modules/Core/include/mitkLookupTableProperty.h
+++ b/Modules/Core/include/mitkLookupTableProperty.h
@@ -1,84 +1,87 @@
/*============================================================================
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 mitkLookupTableProperty_h
#define mitkLookupTableProperty_h
#include "mitkBaseProperty.h"
#include "mitkLookupTable.h"
#include <MitkCoreExports.h>
namespace mitk
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4522)
#endif
/**
* @brief The LookupTableProperty class Property to associate mitk::LookupTable
* to an mitk::DataNode.
* @ingroup DataManagement
*
* @note If you want to use this property to colorize an mitk::Image, make sure
* to set the mitk::RenderingModeProperty to a mode which supports lookup tables
* (e.g. LOOKUPTABLE_COLOR). Make sure to check the documentation of the
* mitk::RenderingModeProperty. For a code example how to use the mitk::LookupTable
* and this property check the mitkImageVtkMapper2DLookupTableTest.cpp in
* Core/Code/Testing.
*/
class MITKCORE_EXPORT LookupTableProperty : public BaseProperty
{
protected:
LookupTable::Pointer m_LookupTable;
LookupTableProperty();
LookupTableProperty(const LookupTableProperty &);
LookupTableProperty(const mitk::LookupTable::Pointer lut);
public:
typedef LookupTable::Pointer ValueType;
mitkClassMacro(LookupTableProperty, BaseProperty);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self)
mitkNewMacro1Param(LookupTableProperty, const mitk::LookupTable::Pointer);
itkGetObjectMacro(LookupTable, LookupTable);
ValueType GetValue() const;
void SetLookupTable(const mitk::LookupTable::Pointer aLookupTable);
void SetValue(const ValueType &);
std::string GetValueAsString() const override;
+ void ToJSON(nlohmann::json& j) const override;
+ void FromJSON(const nlohmann::json& j) override;
+
using BaseProperty::operator=;
private:
// purposely not implemented
LookupTableProperty &operator=(const LookupTableProperty &);
itk::LightObject::Pointer InternalClone() const override;
bool IsEqual(const BaseProperty &property) const override;
bool Assign(const BaseProperty &property) override;
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace mitk
#endif
diff --git a/Modules/Core/include/mitkStringProperty.h b/Modules/Core/include/mitkStringProperty.h
index 04e7d744af..574e426d70 100644
--- a/Modules/Core/include/mitkStringProperty.h
+++ b/Modules/Core/include/mitkStringProperty.h
@@ -1,78 +1,81 @@
/*============================================================================
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 mitkStringProperty_h
#define mitkStringProperty_h
#include <itkConfigure.h>
#include "mitkBaseProperty.h"
#include <MitkCoreExports.h>
#include <string>
namespace mitk
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4522)
#endif
/**
* @brief Property for strings
* @ingroup DataManagement
*/
class MITKCORE_EXPORT StringProperty : public BaseProperty
{
protected:
std::string m_Value;
StringProperty(const char *string = nullptr);
StringProperty(const std::string &s);
StringProperty(const StringProperty &);
public:
mitkClassMacro(StringProperty, BaseProperty);
typedef std::string ValueType;
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
mitkNewMacro1Param(StringProperty, const char*);
mitkNewMacro1Param(StringProperty, const std::string&);
itkGetStringMacro(Value);
itkSetStringMacro(Value);
std::string GetValueAsString() const override;
+ void ToJSON(nlohmann::json& j) const override;
+ void FromJSON(const nlohmann::json& j) override;
+
static const char *PATH;
using BaseProperty::operator=;
private:
// purposely not implemented
StringProperty &operator=(const StringProperty &);
itk::LightObject::Pointer InternalClone() const override;
bool IsEqual(const BaseProperty &property) const override;
bool Assign(const BaseProperty &property) override;
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace mitk
#endif
diff --git a/Modules/Core/src/DataManagement/mitkColorProperty.cpp b/Modules/Core/src/DataManagement/mitkColorProperty.cpp
index 9288a7343e..2340d23b94 100644
--- a/Modules/Core/src/DataManagement/mitkColorProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkColorProperty.cpp
@@ -1,90 +1,100 @@
/*============================================================================
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 "mitkColorProperty.h"
#include <sstream>
mitk::ColorProperty::ColorProperty() : m_Color(0.0f)
{
}
mitk::ColorProperty::ColorProperty(const mitk::ColorProperty &other) : BaseProperty(other), m_Color(other.m_Color)
{
}
mitk::ColorProperty::ColorProperty(const float color[3]) : m_Color(color)
{
}
mitk::ColorProperty::ColorProperty(const float red, const float green, const float blue)
{
m_Color.Set(red, green, blue);
}
mitk::ColorProperty::ColorProperty(const mitk::Color &color) : m_Color(color)
{
}
bool mitk::ColorProperty::IsEqual(const BaseProperty &property) const
{
return this->m_Color == static_cast<const Self &>(property).m_Color;
}
bool mitk::ColorProperty::Assign(const BaseProperty &property)
{
this->m_Color = static_cast<const Self &>(property).m_Color;
return true;
}
const mitk::Color &mitk::ColorProperty::GetColor() const
{
return m_Color;
}
void mitk::ColorProperty::SetColor(const mitk::Color &color)
{
if (m_Color != color)
{
m_Color = color;
Modified();
}
}
void mitk::ColorProperty::SetValue(const mitk::Color &color)
{
SetColor(color);
}
void mitk::ColorProperty::SetColor(float red, float green, float blue)
{
float tmp[3] = {red, green, blue};
SetColor(mitk::Color(tmp));
}
std::string mitk::ColorProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr.imbue(std::locale::classic());
myStr << GetValue();
return myStr.str();
}
const mitk::Color &mitk::ColorProperty::GetValue() const
{
return GetColor();
}
+void mitk::ColorProperty::ToJSON(nlohmann::json& j) const
+{
+ j = this->GetColor();
+}
+
+void mitk::ColorProperty::FromJSON(const nlohmann::json& j)
+{
+ this->SetColor(j.get<Color>());
+}
+
itk::LightObject::Pointer mitk::ColorProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
result->UnRegister();
return result;
}
diff --git a/Modules/Core/src/DataManagement/mitkEnumerationProperty.cpp b/Modules/Core/src/DataManagement/mitkEnumerationProperty.cpp
index e6e3d27852..a898451421 100644
--- a/Modules/Core/src/DataManagement/mitkEnumerationProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkEnumerationProperty.cpp
@@ -1,166 +1,181 @@
/*============================================================================
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 <mitkEnumerationProperty.h>
#include <algorithm>
mitk::EnumerationProperty::EnumerationProperty()
: m_CurrentValue(0)
{
}
mitk::EnumerationProperty::EnumerationProperty(const EnumerationProperty &other)
: BaseProperty(other),
m_CurrentValue(other.m_CurrentValue),
m_IdMap(other.m_IdMap),
m_NameMap(other.m_NameMap)
{
}
bool mitk::EnumerationProperty::AddEnum(const std::string &name, const IdType &id)
{
if (false == this->IsValidEnumerationValue(id) &&
false == this->IsValidEnumerationValue(name))
{
this->GetEnumIds().insert(std::make_pair(id, name));
this->GetEnumStrings().insert(std::make_pair(name, id));
return true;
}
return false;
}
bool mitk::EnumerationProperty::SetValue(const std::string &name)
{
if (this->IsValidEnumerationValue(name))
{
m_CurrentValue = this->GetEnumId(name);
this->Modified();
return true;
}
return false;
}
bool mitk::EnumerationProperty::SetValue(const IdType &id)
{
if (this->IsValidEnumerationValue(id))
{
m_CurrentValue = id;
this->Modified();
return true;
}
return false;
}
mitk::EnumerationProperty::IdType mitk::EnumerationProperty::GetValueAsId() const
{
return m_CurrentValue;
}
std::string mitk::EnumerationProperty::GetValueAsString() const
{
return this->GetEnumString(m_CurrentValue);
}
void mitk::EnumerationProperty::Clear()
{
this->GetEnumIds().clear();
this->GetEnumStrings().clear();
m_CurrentValue = 0;
}
mitk::EnumerationProperty::EnumIdsContainerType::size_type mitk::EnumerationProperty::Size() const
{
return this->GetEnumIds().size();
}
mitk::EnumerationProperty::EnumConstIterator mitk::EnumerationProperty::Begin() const
{
return this->GetEnumIds().cbegin();
}
mitk::EnumerationProperty::EnumConstIterator mitk::EnumerationProperty::End() const
{
return this->GetEnumIds().cend();
}
std::string mitk::EnumerationProperty::GetEnumString(const IdType &id) const
{
return this->IsValidEnumerationValue(id)
? this->GetEnumIds().find(id)->second
: std::string("invalid enum id or enums empty");
}
mitk::EnumerationProperty::IdType mitk::EnumerationProperty::GetEnumId(const std::string &name) const
{
return this->IsValidEnumerationValue(name)
? this->GetEnumStrings().find(name)->second
: 0;
}
bool mitk::EnumerationProperty::IsEqual(const BaseProperty &property) const
{
const auto &other = static_cast<const Self &>(property);
return
this->Size() == other.Size() &&
this->GetValueAsId() == other.GetValueAsId() &&
std::equal(this->Begin(), this->End(), other.Begin());
}
bool mitk::EnumerationProperty::Assign(const BaseProperty &property)
{
const auto &other = static_cast<const Self &>(property);
this->GetEnumIds() = other.GetEnumIds();
this->GetEnumStrings() = other.GetEnumStrings();
m_CurrentValue = other.m_CurrentValue;
return true;
}
bool mitk::EnumerationProperty::IsValidEnumerationValue(const IdType &id) const
{
return this->GetEnumIds().end() != this->GetEnumIds().find(id);
}
bool mitk::EnumerationProperty::IsValidEnumerationValue(const std::string &name) const
{
return this->GetEnumStrings().end() != this->GetEnumStrings().find(name);
}
mitk::EnumerationProperty::EnumIdsContainerType & mitk::EnumerationProperty::GetEnumIds()
{
return m_IdMap;
}
const mitk::EnumerationProperty::EnumIdsContainerType & mitk::EnumerationProperty::GetEnumIds() const
{
return m_IdMap;
}
mitk::EnumerationProperty::EnumStringsContainerType & mitk::EnumerationProperty::GetEnumStrings()
{
return m_NameMap;
}
const mitk::EnumerationProperty::EnumStringsContainerType & mitk::EnumerationProperty::GetEnumStrings() const
{
return m_NameMap;
}
+
+void mitk::EnumerationProperty::ToJSON(nlohmann::json& j) const
+{
+ j = this->GetValueAsString();
+}
+
+void mitk::EnumerationProperty::FromJSON(const nlohmann::json& j)
+{
+ auto name = j.get<std::string>();
+
+ if (!this->IsValidEnumerationValue(name))
+ mitkThrow() << '"' << name << "\" is not a valid enumeration value for " << this->GetNameOfClass() << '!';
+
+ this->SetValue(name);
+}
diff --git a/Modules/Core/src/DataManagement/mitkLookupTableProperty.cpp b/Modules/Core/src/DataManagement/mitkLookupTableProperty.cpp
index c079e4f0c4..d9edff7c6b 100644
--- a/Modules/Core/src/DataManagement/mitkLookupTableProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkLookupTableProperty.cpp
@@ -1,73 +1,149 @@
/*============================================================================
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 "mitkLookupTableProperty.h"
mitk::LookupTableProperty::LookupTableProperty()
{
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
this->SetLookupTable(lut);
}
mitk::LookupTableProperty::LookupTableProperty(const LookupTableProperty &other)
: mitk::BaseProperty(other), m_LookupTable(other.m_LookupTable)
{
}
mitk::LookupTableProperty::LookupTableProperty(const mitk::LookupTable::Pointer lut)
{
this->SetLookupTable(lut);
}
bool mitk::LookupTableProperty::IsEqual(const BaseProperty &property) const
{
return *(this->m_LookupTable) == *(static_cast<const Self &>(property).m_LookupTable);
}
bool mitk::LookupTableProperty::Assign(const BaseProperty &property)
{
this->m_LookupTable = static_cast<const Self &>(property).m_LookupTable;
return true;
}
std::string mitk::LookupTableProperty::GetValueAsString() const
{
std::stringstream ss;
ss << m_LookupTable;
return ss.str();
}
mitk::LookupTableProperty::ValueType mitk::LookupTableProperty::GetValue() const
{
return m_LookupTable;
}
void mitk::LookupTableProperty::SetLookupTable(const mitk::LookupTable::Pointer aLookupTable)
{
if ((m_LookupTable != aLookupTable) || (*m_LookupTable != *aLookupTable))
{
m_LookupTable = aLookupTable;
Modified();
}
}
void mitk::LookupTableProperty::SetValue(const ValueType &value)
{
SetLookupTable(value);
}
+void mitk::LookupTableProperty::ToJSON(nlohmann::json& j) const
+{
+ auto lut = this->GetValue()->GetVtkLookupTable();
+
+ auto table = nlohmann::json::array();
+ auto numTableValues = lut->GetNumberOfTableValues();
+
+ for (decltype(numTableValues) i = 0; i < numTableValues; ++i)
+ {
+ auto value = nlohmann::json::array();
+
+ for (size_t j = 0; j < 4; ++j)
+ value.push_back(lut->GetTableValue(i)[j]);
+
+ table.push_back(value);
+ }
+
+ j = nlohmann::json::object({
+ { "NumberOfColors", static_cast<int>(lut->GetNumberOfTableValues()) },
+ { "Scale", lut->GetScale() },
+ { "Ramp", lut->GetRamp() },
+ { "HueRange", nlohmann::json::array({ lut->GetHueRange()[0], lut->GetHueRange()[1] }) },
+ { "ValueRange", nlohmann::json::array({ lut->GetValueRange()[0], lut->GetValueRange()[1] }) },
+ { "SaturationRange", nlohmann::json::array({ lut->GetSaturationRange()[0], lut->GetSaturationRange()[1] }) },
+ { "AlphaRange", nlohmann::json::array({ lut->GetAlphaRange()[0], lut->GetAlphaRange()[1] }) },
+ { "TableRange", nlohmann::json::array({ lut->GetTableRange()[0], lut->GetTableRange()[1] }) },
+ { "Table", table }
+ });
+}
+
+void mitk::LookupTableProperty::FromJSON(const nlohmann::json& j)
+{
+ auto lut = vtkSmartPointer<vtkLookupTable>::New();
+
+ lut->SetNumberOfTableValues(j["NumberOfColors"].get<int>());
+ lut->SetScale(j["Scale"].get<int>());
+ lut->SetScale(j["Ramp"].get<int>());
+
+ std::array<double, 2> range;
+
+ j["HueRange"][0].get_to(range[0]);
+ j["HueRange"][1].get_to(range[1]);
+ lut->SetHueRange(range.data());
+
+ j["ValueRange"][0].get_to(range[0]);
+ j["ValueRange"][1].get_to(range[1]);
+ lut->SetValueRange(range.data());
+
+ j["SaturationRange"][0].get_to(range[0]);
+ j["SaturationRange"][1].get_to(range[1]);
+ lut->SetSaturationRange(range.data());
+
+ j["AlphaRange"][0].get_to(range[0]);
+ j["AlphaRange"][1].get_to(range[1]);
+ lut->SetAlphaRange(range.data());
+
+ j["TableRange"][0].get_to(range[0]);
+ j["TableRange"][1].get_to(range[1]);
+ lut->SetTableRange(range.data());
+
+ std::array<double, 4> rgba;
+ vtkIdType i = 0;
+
+ for (const auto& value : j["Table"])
+ {
+ for (size_t j = 0; j < 4; ++j)
+ value[j].get_to(rgba[j]);
+
+ lut->SetTableValue(i++, rgba.data());
+ }
+
+ auto mitkLut = LookupTable::New();
+ mitkLut->SetVtkLookupTable(lut);
+ this->SetLookupTable(mitkLut);
+}
+
itk::LightObject::Pointer mitk::LookupTableProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
result->UnRegister();
return result;
}
diff --git a/Modules/Core/src/DataManagement/mitkStringProperty.cpp b/Modules/Core/src/DataManagement/mitkStringProperty.cpp
index 767d6101c1..88b088ef25 100644
--- a/Modules/Core/src/DataManagement/mitkStringProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkStringProperty.cpp
@@ -1,51 +1,61 @@
/*============================================================================
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 "mitkStringProperty.h"
const char *mitk::StringProperty::PATH = "path";
mitk::StringProperty::StringProperty(const char *string) : m_Value()
{
if (string)
m_Value = string;
}
mitk::StringProperty::StringProperty(const std::string &s) : m_Value(s)
{
}
mitk::StringProperty::StringProperty(const StringProperty &other) : BaseProperty(other), m_Value(other.m_Value)
{
}
bool mitk::StringProperty::IsEqual(const BaseProperty &property) const
{
return this->m_Value == static_cast<const Self &>(property).m_Value;
}
bool mitk::StringProperty::Assign(const BaseProperty &property)
{
this->m_Value = static_cast<const Self &>(property).m_Value;
return true;
}
std::string mitk::StringProperty::GetValueAsString() const
{
return m_Value;
}
+void mitk::StringProperty::ToJSON(nlohmann::json& j) const
+{
+ j = this->GetValueAsString();
+}
+
+void mitk::StringProperty::FromJSON(const nlohmann::json& j)
+{
+ this->SetValue(j.get<std::string>());
+}
+
itk::LightObject::Pointer mitk::StringProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
result->UnRegister();
return result;
}