diff --git a/Modules/ROI/autoload/IO/src/mitkROIIO.cpp b/Modules/ROI/autoload/IO/src/mitkROIIO.cpp
index 31a8e2c1ee..9cbc5fc05e 100644
--- a/Modules/ROI/autoload/IO/src/mitkROIIO.cpp
+++ b/Modules/ROI/autoload/IO/src/mitkROIIO.cpp
@@ -1,156 +1,210 @@
/*============================================================================
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 "mitkROIIO.h"
#include <mitkProportionalTimeGeometry.h>
#include <mitkROI.h>
#include <mitkROIIOMimeTypes.h>
-#include <nlohmann/json.hpp>
-
#include <filesystem>
#include <fstream>
namespace
{
- mitk::TimeGeometry::Pointer ReadGeometry(const nlohmann::json& jsonGeometry)
+ int CheckFileFormat(const nlohmann::json& json)
+ {
+ if ("MITK ROI" != json["FileFormat"].get<std::string>())
+ mitkThrow() << "Unknown file format (expected \"MITK ROI\")!";
+
+ auto version = json["Version"].get<int>();
+
+ if (1 != version)
+ mitkThrow() << "Unknown file format version (expected version 1)!";
+
+ return version;
+ }
+
+ mitk::Vector3D GetSize(const mitk::BaseGeometry* geometry)
+ {
+ auto bounds = geometry->GetBounds();
+
+ mitk::Vector3D result;
+ result[0] = bounds[1];
+ result[1] = bounds[3];
+ result[2] = bounds[5];
+
+ return result;
+ }
+
+ void SetSize(mitk::BaseGeometry* geometry, const mitk::Vector3D& size)
+ {
+ mitk::BaseGeometry::BoundsArrayType bounds({ 0.0, size[0], 0.0, size[1], 0.0, size[2] });
+ geometry->SetBounds(bounds);
+ }
+
+ mitk::TimeGeometry::Pointer ReadGeometry(const nlohmann::json& jGeometry)
{
auto geometry = mitk::Geometry3D::New();
geometry->ImageGeometryOn();
- if (!jsonGeometry.is_object())
+ if (!jGeometry.is_object())
mitkThrow() << "Geometry is expected to be a JSON object.";
- if (jsonGeometry.contains("Origin"))
- geometry->SetOrigin(jsonGeometry["Origin"].get<mitk::Point3D>());
+ if (jGeometry.contains("Origin"))
+ geometry->SetOrigin(jGeometry["Origin"].get<mitk::Point3D>());
- if (jsonGeometry.contains("Spacing"))
- geometry->SetSpacing(jsonGeometry["Spacing"].get<mitk::Vector3D>());
+ if (jGeometry.contains("Spacing"))
+ geometry->SetSpacing(jGeometry["Spacing"].get<mitk::Vector3D>());
- if (jsonGeometry.contains("Size"))
- {
- auto size = jsonGeometry["Size"].get<mitk::Vector3D>();
- mitk::BaseGeometry::BoundsArrayType bounds({ 0.0, size[0], 0.0, size[1], 0.0, size[2] });
- geometry->SetBounds(bounds);
- }
+ if (jGeometry.contains("Size"))
+ SetSize(geometry, jGeometry["Size"].get<mitk::Vector3D>());
- auto timeSteps = jsonGeometry.contains("TimeSteps")
- ? jsonGeometry["TimeSteps"].get<mitk::TimeStepType>()
+ auto timeSteps = jGeometry.contains("TimeSteps")
+ ? jGeometry["TimeSteps"].get<mitk::TimeStepType>()
: 1;
auto result = mitk::ProportionalTimeGeometry::New();
result->Initialize(geometry, timeSteps);
return result;
}
+
+ nlohmann::json WriteGeometry(const mitk::TimeGeometry* timeGeometry)
+ {
+ auto geometry = timeGeometry->GetGeometryForTimeStep(0);
+
+ nlohmann::json result = {
+ { "Origin", geometry->GetOrigin() },
+ { "Spacing", geometry->GetSpacing() },
+ { "Size", GetSize(geometry) }
+ };
+
+ auto timeSteps = timeGeometry->CountTimeSteps();
+
+ if (timeSteps > 1)
+ result["TimeSteps"] = timeSteps;
+
+ return result;
+ }
}
mitk::ROIIO::ROIIO()
: AbstractFileIO(ROI::GetStaticNameOfClass(), MitkROIIOMimeTypes::ROI_MIMETYPE(), "MITK ROI")
{
this->RegisterService();
}
std::vector<mitk::BaseData::Pointer> mitk::ROIIO::DoRead()
{
auto *stream = this->GetInputStream();
std::ifstream fileStream;
if (nullptr == stream)
{
auto filename = this->GetInputLocation();
if (filename.empty() || !std::filesystem::exists(filename))
mitkThrow() << "Invalid or nonexistent filename: \"" << filename << "\"!";
fileStream.open(filename);
if (!fileStream.is_open())
mitkThrow() << "Could not open file \"" << filename << "\" for reading!";
stream = &fileStream;
}
auto result = ROI::New();
try
{
- auto json = nlohmann::json::parse(*stream);
+ auto j = nlohmann::json::parse(*stream);
- if ("MITK ROI" != json["FileFormat"].get<std::string>())
- mitkThrow() << "Unknown file format (expected \"MITK ROI\")!";
+ CheckFileFormat(j);
- if (1 != json["Version"].get<int>())
- mitkThrow() << "Unknown file format version (expected version 1)!";
+ auto geometry = ReadGeometry(j["Geometry"]);
+ result->SetTimeGeometry(geometry);
+
+ if (j.contains("Name"))
+ result->SetProperty("name", mitk::StringProperty::New(j["Name"].get<std::string>()));
- result->SetTimeGeometry(ReadGeometry(json["Geometry"]));
-
- if (json.contains("Properties"))
- {
- auto properties = mitk::PropertyList::New();
- properties->FromJSON(json["Properties"]);
- result->GetPropertyList()->ConcatenatePropertyList(properties);
- }
-
- for (const auto& jsonROI : json["ROIs"])
- {
- ROI::Element roi(jsonROI["ID"].get<unsigned int>());
-
- if (jsonROI.contains("TimeSteps"))
- {
- for (const auto& jsonTimeStep : jsonROI["TimeSteps"])
- {
- auto t = jsonTimeStep["t"].get<TimeStepType>();
-
- roi.SetMin(jsonTimeStep["Min"].get<Point3D>(), t);
- roi.SetMax(jsonTimeStep["Max"].get<Point3D>(), t);
-
- if (jsonTimeStep.contains("Properties"))
- {
- auto properties = mitk::PropertyList::New();
- properties->FromJSON(jsonTimeStep["Properties"]);
- roi.SetProperties(properties, t);
- }
- }
- }
- else
- {
- roi.SetMin(jsonROI["Min"].get<Point3D>());
- roi.SetMax(jsonROI["Max"].get<Point3D>());
- }
-
- if (jsonROI.contains("Properties"))
- {
- auto properties = mitk::PropertyList::New();
- properties->FromJSON(jsonROI["Properties"]);
- roi.SetDefaultProperties(properties);
- }
-
- result->AddElement(roi);
- }
+ if (j.contains("Caption"))
+ result->SetProperty("caption", mitk::StringProperty::New(j["Caption"].get<std::string>()));
+
+ for (const auto& roi : j["ROIs"])
+ result->AddElement(roi.get<ROI::Element>());
}
catch (const nlohmann::json::exception &e)
{
mitkThrow() << e.what();
}
return { result };
}
void mitk::ROIIO::Write()
{
+ auto input = dynamic_cast<const ROI*>(this->GetInput());
+
+ if (input == nullptr)
+ mitkThrow() << "Invalid input for writing!";
+
+ if (input->GetNumberOfElements() == 0)
+ mitkThrow() << "No ROIs found!";
+
+ auto* stream = this->GetOutputStream();
+ std::ofstream fileStream;
+
+ if (stream == nullptr)
+ {
+ auto filename = this->GetOutputLocation();
+
+ if (filename.empty())
+ mitkThrow() << "Neither an output stream nor an output filename was specified!";
+
+ fileStream.open(filename);
+
+ if (!fileStream.is_open())
+ mitkThrow() << "Could not open file \"" << filename << "\" for writing!";
+
+ stream = &fileStream;
+ }
+
+ if (!stream->good())
+ mitkThrow() << "Stream for writing is not good!";
+
+ nlohmann::ordered_json j = {
+ { "FileFormat", "MITK ROI" },
+ { "Version", 1 },
+ { "Name", input->GetProperty("name")->GetValueAsString() },
+ { "Geometry", WriteGeometry(input->GetTimeGeometry()) }
+ };
+
+ auto caption = input->GetConstProperty("caption");
+
+ if (caption.IsNotNull())
+ j["Caption"] = caption->GetValueAsString();
+
+ nlohmann::json rois;
+
+ for (const auto& roi : *input)
+ rois.push_back(roi.second);
+
+ j["ROIs"] = rois;
+
+ *stream << std::setw(2) << j << std::endl;
}
mitk::ROIIO* mitk::ROIIO::IOClone() const
{
return new ROIIO(*this);
}
diff --git a/Modules/ROI/include/mitkROI.h b/Modules/ROI/include/mitkROI.h
index 0e76d25c22..d580f5f9b5 100644
--- a/Modules/ROI/include/mitkROI.h
+++ b/Modules/ROI/include/mitkROI.h
@@ -1,104 +1,109 @@
/*============================================================================
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 mitkROI_h
#define mitkROI_h
#include <mitkBaseData.h>
#include <MitkROIExports.h>
namespace mitk
{
class MITKROI_EXPORT ROI : public BaseData
{
public:
class MITKROI_EXPORT Element : public IPropertyOwner
{
public:
using PointsType = std::map<TimeStepType, Point3D>;
using PropertyListsType = std::map<TimeStepType, PropertyList::Pointer>;
Element();
explicit Element(unsigned int id);
~Element() = default;
BaseProperty::ConstPointer GetConstProperty(const std::string& propertyKey, const std::string& contextName = "", bool fallBackOnDefaultContext = true) const override;
std::vector<std::string> GetPropertyKeys(const std::string& contextName = "", bool includeDefaultContext = false) const override;
std::vector<std::string> GetPropertyContextNames() const override;
BaseProperty* GetNonConstProperty(const std::string& propertyKey, const std::string& contextName = "", bool fallBackOnDefaultContext = true) override;
void SetProperty(const std::string& propertyKey, BaseProperty* property, const std::string& contextName = "", bool fallBackOnDefaultContext = false) override;
void RemoveProperty(const std::string& propertyKey, const std::string& contextName = "", bool fallBackOnDefaultContext = false) override;
unsigned int GetID() const;
void SetID(unsigned int id);
bool HasTimeStep(TimeStepType t) const;
+ bool HasTimeSteps() const;
+ std::vector<TimeStepType> GetTimeSteps() const;
Point3D GetMin(TimeStepType t = 0) const;
void SetMin(const Point3D& min, TimeStepType t = 0);
Point3D GetMax(TimeStepType t = 0) const;
void SetMax(const Point3D& max, TimeStepType t = 0);
PropertyList* GetDefaultProperties() const;
void SetDefaultProperties(PropertyList* properties);
PropertyList* GetProperties(TimeStepType t = 0) const;
void SetProperties(PropertyList* properties, TimeStepType t = 0);
private:
unsigned int m_ID;
PointsType m_Min;
PointsType m_Max;
PropertyList::Pointer m_DefaultProperties;
PropertyListsType m_Properties;
};
mitkClassMacro(ROI, BaseData)
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
using ElementsType = std::map<unsigned int, Element>;
using Iterator = ElementsType::iterator;
using ConstIterator = ElementsType::const_iterator;
size_t GetNumberOfElements() const;
void AddElement(const Element& element);
const Element& GetElement(unsigned int id) const;
Element& GetElement(unsigned int id);
ConstIterator begin() const;
ConstIterator end() const;
Iterator begin();
Iterator end();
void SetRequestedRegionToLargestPossibleRegion() override;
bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
bool VerifyRequestedRegion() override;
void SetRequestedRegion(const itk::DataObject* data) override;
protected:
mitkCloneMacro(Self)
ROI();
ROI(const Self& other);
~ROI() override;
private:
ElementsType m_Elements;
};
+
+ MITKROI_EXPORT void to_json(nlohmann::json& j, const ROI::Element& roi);
+ MITKROI_EXPORT void from_json(const nlohmann::json& j, ROI::Element& roi);
}
#endif
diff --git a/Modules/ROI/src/mitkROI.cpp b/Modules/ROI/src/mitkROI.cpp
index 7243726046..263392da58 100644
--- a/Modules/ROI/src/mitkROI.cpp
+++ b/Modules/ROI/src/mitkROI.cpp
@@ -1,282 +1,369 @@
/*============================================================================
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 <mitkROI.h>
+void mitk::to_json(nlohmann::json& j, const ROI::Element& roi)
+{
+ j["ID"] = roi.GetID();
+
+ if (roi.HasTimeSteps())
+ {
+ auto timeSteps = roi.GetTimeSteps();
+
+ for (const auto t : timeSteps)
+ {
+ nlohmann::json jTimeStep = {
+ { "t", t },
+ { "Min", roi.GetMin(t) },
+ { "Max", roi.GetMax(t) }
+ };
+
+ if (auto* properties = roi.GetProperties(t); properties != nullptr && !properties->IsEmpty())
+ properties->ToJSON(jTimeStep["Properties"]);
+
+ j["TimeSteps"].push_back(jTimeStep);
+ }
+ }
+ else
+ {
+ j["Min"] = roi.GetMin();
+ j["Max"] = roi.GetMax();
+ }
+
+ if (auto* properties = roi.GetDefaultProperties(); properties != nullptr && !properties->IsEmpty())
+ properties->ToJSON(j["Properties"]);
+}
+
+void mitk::from_json(const nlohmann::json& j, ROI::Element& roi)
+{
+ auto id = j["ID"].get<unsigned int>();
+ roi.SetID(id);
+
+ if (j.contains("TimeSteps"))
+ {
+ for (const auto& jTimeStep : j["TimeSteps"])
+ {
+ auto t = jTimeStep["t"].get<TimeStepType>();
+
+ roi.SetMin(jTimeStep["Min"].get<Point3D>(), t);
+ roi.SetMax(jTimeStep["Max"].get<Point3D>(), t);
+
+ if (jTimeStep.contains("Properties"))
+ {
+ auto properties = mitk::PropertyList::New();
+ properties->FromJSON(jTimeStep["Properties"]);
+ roi.SetProperties(properties, t);
+ }
+ }
+ }
+ else
+ {
+ roi.SetMin(j["Min"].get<Point3D>());
+ roi.SetMax(j["Max"].get<Point3D>());
+ }
+
+ if (j.contains("Properties"))
+ {
+ auto properties = mitk::PropertyList::New();
+ properties->FromJSON(j["Properties"]);
+ roi.SetDefaultProperties(properties);
+ }
+}
+
mitk::ROI::Element::Element()
: Element(0)
{
}
mitk::ROI::Element::Element(unsigned int id)
: m_ID(id),
m_DefaultProperties(PropertyList::New())
{
}
unsigned int mitk::ROI::Element::GetID() const
{
return m_ID;
}
void mitk::ROI::Element::SetID(unsigned int id)
{
m_ID = id;
}
bool mitk::ROI::Element::HasTimeStep(TimeStepType t) const
{
return m_Min.count(t) != 0 && m_Max.count(t) != 0;
}
+bool mitk::ROI::Element::HasTimeSteps() const
+{
+ return m_Min.size() > 1 && m_Max.size() > 1;
+}
+
+std::vector<mitk::TimeStepType> mitk::ROI::Element::GetTimeSteps() const
+{
+ std::vector<TimeStepType> result;
+ result.reserve(m_Min.size());
+
+ for (const auto& [t, min] : m_Min)
+ {
+ if (m_Max.count(t) != 0)
+ result.push_back(t);
+ }
+
+ return result;
+}
+
mitk::Point3D mitk::ROI::Element::GetMin(TimeStepType t) const
{
return m_Min.at(t);
}
void mitk::ROI::Element::SetMin(const Point3D& min, TimeStepType t)
{
m_Min[t] = min;
}
mitk::Point3D mitk::ROI::Element::GetMax(TimeStepType t) const
{
return m_Max.at(t);
}
void mitk::ROI::Element::SetMax(const Point3D& max, TimeStepType t)
{
m_Max[t] = max;
}
mitk::PropertyList* mitk::ROI::Element::GetDefaultProperties() const
{
return m_DefaultProperties;
}
void mitk::ROI::Element::SetDefaultProperties(PropertyList* properties)
{
m_DefaultProperties = properties;
}
mitk::PropertyList* mitk::ROI::Element::GetProperties(TimeStepType t) const
{
if (m_Properties.count(t) != 0)
return m_Properties.at(t);
return nullptr;
}
void mitk::ROI::Element::SetProperties(PropertyList* properties, TimeStepType t)
{
m_Properties[t] = properties;
}
mitk::BaseProperty::ConstPointer mitk::ROI::Element::GetConstProperty(const std::string& propertyKey, const std::string& contextName, bool fallBackOnDefaultContext) const
{
if (!contextName.empty())
{
const TimeStepType t = std::stoul(contextName);
auto it = m_Properties.find(t);
if (it != m_Properties.end() && it->second.IsNotNull())
{
auto property = it->second->GetConstProperty(propertyKey);
if (property.IsNotNull())
return property;
}
if (!fallBackOnDefaultContext)
return nullptr;
}
return m_DefaultProperties->GetConstProperty(propertyKey);
}
std::vector<std::string> mitk::ROI::Element::GetPropertyKeys(const std::string& contextName, bool includeDefaultContext) const
{
if (!contextName.empty())
{
const TimeStepType t = std::stoul(contextName);
auto it = m_Properties.find(t);
std::vector<std::string> result;
if (it != m_Properties.end() && it->second.IsNotNull())
result = it->second->GetPropertyKeys();
if (includeDefaultContext)
{
auto keys = m_DefaultProperties->GetPropertyKeys();
auto end = result.cend();
std::remove_copy_if(keys.cbegin(), keys.cend(), std::back_inserter(result), [&, result, end](const std::string& key) {
return end != std::find(result.cbegin(), end, key);
});
}
return result;
}
return m_DefaultProperties->GetPropertyKeys();
}
std::vector<std::string> mitk::ROI::Element::GetPropertyContextNames() const
{
std::vector<std::string> result;
result.reserve(m_Properties.size());
std::transform(m_Properties.cbegin(), m_Properties.cend(), std::back_inserter(result), [](const PropertyListsType::value_type& property) {
return std::to_string(property.first);
});
return result;
}
mitk::BaseProperty* mitk::ROI::Element::GetNonConstProperty(const std::string& propertyKey, const std::string& contextName, bool fallBackOnDefaultContext)
{
if (!contextName.empty())
{
const TimeStepType t = std::stoul(contextName);
auto it = m_Properties.find(t);
if (it != m_Properties.end() && it->second.IsNotNull())
{
auto* property = it->second->GetNonConstProperty(propertyKey);
if (property != nullptr)
return property;
}
if (!fallBackOnDefaultContext)
return nullptr;
}
return m_DefaultProperties->GetNonConstProperty(propertyKey);
}
void mitk::ROI::Element::SetProperty(const std::string& propertyKey, BaseProperty* property, const std::string& contextName, bool fallBackOnDefaultContext)
{
if (!contextName.empty())
{
const TimeStepType t = std::stoul(contextName);
auto it = m_Properties.find(t);
if (it != m_Properties.end() && it->second.IsNotNull())
{
it->second->SetProperty(propertyKey, property);
}
else if (!fallBackOnDefaultContext)
{
mitkThrow() << "Context \"" << contextName << "\" does not exist!";
}
}
m_DefaultProperties->SetProperty(propertyKey, property);
}
void mitk::ROI::Element::RemoveProperty(const std::string& propertyKey, const std::string& contextName, bool fallBackOnDefaultContext)
{
if (!contextName.empty())
{
const TimeStepType t = std::stoul(contextName);
auto it = m_Properties.find(t);
if (it != m_Properties.end() && it->second.IsNotNull())
{
it->second->RemoveProperty(propertyKey);
}
else if (!fallBackOnDefaultContext)
{
mitkThrow() << "Context \"" << contextName << "\" does not exist!";
}
}
m_DefaultProperties->RemoveProperty(propertyKey);
}
mitk::ROI::ROI()
{
}
mitk::ROI::ROI(const Self& other)
: BaseData(other)
{
}
mitk::ROI::~ROI()
{
}
size_t mitk::ROI::GetNumberOfElements() const
{
return m_Elements.size();
}
void mitk::ROI::AddElement(const Element& element)
{
const auto id = element.GetID();
if (m_Elements.count(id) != 0)
mitkThrow() << "ROI already contains an element with ID " << std::to_string(id) << '.';
m_Elements[id] = element;
}
const mitk::ROI::Element& mitk::ROI::GetElement(unsigned int id) const
{
return m_Elements.at(id);
}
mitk::ROI::Element& mitk::ROI::GetElement(unsigned int id)
{
return m_Elements.at(id);
}
mitk::ROI::ConstIterator mitk::ROI::begin() const
{
return m_Elements.begin();
}
mitk::ROI::ConstIterator mitk::ROI::end() const
{
return m_Elements.end();
}
mitk::ROI::Iterator mitk::ROI::begin()
{
return m_Elements.begin();
}
mitk::ROI::Iterator mitk::ROI::end()
{
return m_Elements.end();
}
void mitk::ROI::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::ROI::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::ROI::VerifyRequestedRegion()
{
return true;
}
void mitk::ROI::SetRequestedRegion(const itk::DataObject* data)
{
}