diff --git a/Modules/Core/include/mitkDataNode.h b/Modules/Core/include/mitkDataNode.h
index 74dedd5ae5..b90c2e03e8 100644
--- a/Modules/Core/include/mitkDataNode.h
+++ b/Modules/Core/include/mitkDataNode.h
@@ -1,598 +1,618 @@
/*============================================================================
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 DATATREENODE_H_HEADER_INCLUDED_C1E14338
#define DATATREENODE_H_HEADER_INCLUDED_C1E14338
#include "mitkBaseData.h"
//#include "mitkMapper.h"
#include "mitkDataInteractor.h"
#include "mitkIdentifiable.h"
#include "mitkIPropertyOwner.h"
#include <fstream>
#include <iostream>
#include "mitkColorProperty.h"
#include "mitkPropertyList.h"
#include "mitkStringProperty.h"
//#include "mitkMapper.h"
#include "mitkGeometry3D.h"
#include "mitkLevelWindow.h"
#include <map>
#include <set>
class vtkLinearTransform;
namespace mitk
{
class BaseRenderer;
class Mapper;
/**
* \brief Definition of an itk::Event that is invoked when
* a DataInteractor is set on this DataNode.
*/
itkEventMacroDeclaration(InteractorChangedEvent, itk::AnyEvent);
/**
* \brief Class for nodes of the DataTree
*
* Contains the data (instance of BaseData), a list of mappers, which can
* draw the data, a transform (vtkTransform) and a list of properties
* (PropertyList).
* \ingroup DataManagement
*
* \todo clean up all the GetProperty methods. There are too many different flavours... Can most probably be reduced
* to
* <tt>bool GetProperty<type>(type&)</tt>
*
* \warning Change in semantics of SetProperty() since Aug 25th 2006. Check your usage of this method if you do
* more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
*/
class MITKCORE_EXPORT DataNode : public itk::DataObject, public IPropertyOwner
{
public:
typedef mitk::Geometry3D::Pointer Geometry3DPointer;
typedef std::vector<itk::SmartPointer<Mapper>> MapperVector;
typedef std::map<std::string, mitk::PropertyList::Pointer> MapOfPropertyLists;
typedef std::vector<MapOfPropertyLists::key_type> PropertyListKeyNames;
typedef std::set<std::string> GroupTagList;
mitkClassMacroItkParent(DataNode, itk::DataObject);
itkFactorylessNewMacro(Self);
// IPropertyProvider
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;
// IPropertyOwner
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;
mitk::Mapper *GetMapper(MapperSlotId id) const;
/**
* \brief Get the data object (instance of BaseData, e.g., an Image)
* managed by this DataNode
*/
BaseData *GetData() const;
/**
* \brief Get the transformation applied prior to displaying the data as
* a vtkTransform
* \deprecated use GetData()->GetGeometry()->GetVtkTransform() instead
*/
vtkLinearTransform *GetVtkTransform(int t = 0) const;
/**
* \brief Set the data object (instance of BaseData, e.g., an Image)
* managed by this DataNode
*
* Prior set properties are kept if previous data of the node already exists and has the same
* type as the new data to be set. Otherwise, the default properties are used.
* In case that previous data already exists, the property list of the data node is cleared
* before setting new default properties.
*
* \warning the actor-mode of the vtkInteractor does not work any more, if the transform of the
* data-tree-node is connected to the transform of the basedata via vtkTransform->SetInput.
*/
virtual void SetData(mitk::BaseData *baseData);
/**
* \brief Set the Interactor.
*/
virtual void SetDataInteractor(const DataInteractor::Pointer interactor);
virtual DataInteractor::Pointer GetDataInteractor() const;
mitk::DataNode &operator=(const DataNode &right);
mitk::DataNode &operator=(BaseData *right);
virtual void SetMapper(MapperSlotId id, mitk::Mapper *mapper);
void UpdateOutputInformation() override;
void SetRequestedRegionToLargestPossibleRegion() override;
bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
bool VerifyRequestedRegion() override;
void SetRequestedRegion(const itk::DataObject *data) override;
void CopyInformation(const itk::DataObject *data) override;
/**
* \brief The "names" used for (renderer-specific) PropertyLists in GetPropertyList(string).
*
* All possible values for the "renderer" parameters of
* the diverse GetProperty/List() methods.
*/
PropertyListKeyNames GetPropertyListNames() const;
/**
* \brief Set the property (instance of BaseProperty) with key \a propertyKey in the PropertyList
* of the \a renderer (if nullptr, use BaseRenderer-independent PropertyList). This is set-by-value.
*
* \warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do
* more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
*
* \sa GetProperty
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
void SetProperty(const char *propertyKey, BaseProperty *property, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Replace the property (instance of BaseProperty) with key \a propertyKey in the PropertyList
* of the \a renderer (if nullptr, use BaseRenderer-independent PropertyList). This is set-by-reference.
*
* If \a renderer is \a nullptr the property is set in the BaseRenderer-independent
* PropertyList of this DataNode.
* \sa GetProperty
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
void ReplaceProperty(const char *propertyKey, BaseProperty *property, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Add the property (instance of BaseProperty) if it does
* not exist (or always if\a overwrite is\a true)
* with key \a propertyKey in the PropertyList
* of the \a renderer (if nullptr, use BaseRenderer-independent
* PropertyList). This is set-by-value.
*
* For\a overwrite ==\a false the property is\em not changed
* if it already exists. For\a overwrite ==\a true the method
* is identical to SetProperty.
*
* \sa SetProperty
* \sa GetProperty
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
void AddProperty(const char *propertyKey,
BaseProperty *property,
const mitk::BaseRenderer *renderer = nullptr,
bool overwrite = false);
/**
* \brief Get the PropertyList of the \a renderer. If \a renderer is \a
* nullptr, the BaseRenderer-independent PropertyList of this DataNode
* is returned.
* \sa GetProperty
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
mitk::PropertyList *GetPropertyList(const mitk::BaseRenderer *renderer = nullptr) const;
mitk::PropertyList *GetPropertyList(const std::string &rendererName) const;
/**
* \brief Add values from another PropertyList.
*
* Overwrites values in m_PropertyList only when possible (i.e. when types are compatible).
* If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty,
* set \c replace .
*
* \param replace true: if \param pList contains a property "visible" of type ColorProperty and our m_PropertyList
* also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects
* behind the pointer.
*
* \sa SetProperty
* \sa ReplaceProperty
* \sa m_PropertyList
*/
void ConcatenatePropertyList(PropertyList *pList, bool replace = false);
/**
* \brief Get the property (instance of BaseProperty) with key \a propertyKey from the PropertyList
* of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
*
* If \a renderer is \a nullptr or the \a propertyKey cannot be found
* in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
* PropertyList of this DataNode is queried.
*
* If \a fallBackOnDataProperties is true, the data property list is queried as a last resort.
*
* \sa GetPropertyList
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
mitk::BaseProperty *GetProperty(const char *propertyKey, const mitk::BaseRenderer *renderer = nullptr, bool fallBackOnDataProperties = true) const;
/**
* \brief Get the property of type T with key \a propertyKey from the PropertyList
* of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
*
* If \a renderer is \a nullptr or the \a propertyKey cannot be found
* in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
* PropertyList of this DataNode is queried.
* \sa GetPropertyList
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
template <typename T>
bool GetProperty(itk::SmartPointer<T> &property,
const char *propertyKey,
const mitk::BaseRenderer *renderer = nullptr) const
{
property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
return property.IsNotNull();
}
/**
* \brief Get the property of type T with key \a propertyKey from the PropertyList
* of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
*
* If \a renderer is \a nullptr or the \a propertyKey cannot be found
* in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
* PropertyList of this DataNode is queried.
* \sa GetPropertyList
* \sa m_PropertyList
* \sa m_MapOfPropertyLists
*/
template <typename T>
bool GetProperty(T *&property, const char *propertyKey, const mitk::BaseRenderer *renderer = nullptr) const
{
property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
return property != nullptr;
}
/**
* \brief Convenience access method for GenericProperty<T> properties
* (T being the type of the second parameter)
* \return \a true property was found
*/
template <typename T>
bool GetPropertyValue(const char *propertyKey, T &value, const mitk::BaseRenderer *renderer = nullptr) const
{
GenericProperty<T> *gp = dynamic_cast<GenericProperty<T> *>(GetProperty(propertyKey, renderer));
if (gp != nullptr)
{
value = gp->GetValue();
return true;
}
return false;
}
/// \brief Get a set of all group tags from this node's property list
GroupTagList GetGroupTags() const;
/**
* \brief Convenience access method for bool properties (instances of
* BoolProperty)
* \return \a true property was found
*/
bool GetBoolProperty(const char *propertyKey, bool &boolValue, const mitk::BaseRenderer *renderer = nullptr) const;
/**
* \brief Convenience access method for int properties (instances of
* IntProperty)
* \return \a true property was found
*/
bool GetIntProperty(const char *propertyKey, int &intValue, const mitk::BaseRenderer *renderer = nullptr) const;
/**
* \brief Convenience access method for float properties (instances of
* FloatProperty)
* \return \a true property was found
*/
bool GetFloatProperty(const char *propertyKey,
float &floatValue,
const mitk::BaseRenderer *renderer = nullptr) const;
/**
* \brief Convenience access method for double properties (instances of
* DoubleProperty)
*
* If there is no DoubleProperty for the given\c propertyKey argument, the method
* looks for a corresponding FloatProperty instance.
*
* \return \a true property was found
*/
bool GetDoubleProperty(const char *propertyKey,
double &doubleValue,
const mitk::BaseRenderer *renderer = nullptr) const;
/**
* \brief Convenience access method for string properties (instances of
* StringProperty)
* \return \a true property was found
*/
bool GetStringProperty(const char *propertyKey,
std::string &string,
const mitk::BaseRenderer *renderer = nullptr) const;
/**
* \brief Convenience access method for color properties (instances of
* ColorProperty)
* \return \a true property was found
*/
bool GetColor(float rgb[3], const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "color") const;
/**
* \brief Convenience access method for level-window properties (instances of
* LevelWindowProperty)
* \return \a true property was found
*/
bool GetLevelWindow(mitk::LevelWindow &levelWindow,
const mitk::BaseRenderer *renderer = nullptr,
const char *propertyKey = "levelwindow") const;
/**
* \brief set the node as selected
*/
void SetSelected(bool selected, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief set the node as selected
* \return \a true node is selected
*/
bool IsSelected(const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Convenience access method for accessing the name of an object (instance of
* StringProperty with property-key "name")
* \return \a true property was found
*/
bool GetName(std::string &nodeName,
const mitk::BaseRenderer *renderer = nullptr,
const char *propertyKey = "name") const
{
return GetStringProperty(propertyKey, nodeName, renderer);
}
/**
* \brief Extra convenience access method for accessing the name of an object (instance of
* StringProperty with property-key "name").
*
* This method does not take the renderer specific
* propertylists into account, because the name of an object should never be renderer specific.
* \returns a std::string with the name of the object (content of "name" Property).
* If there is no "name" Property, an empty string will be returned.
*/
virtual std::string GetName() const
{
mitk::StringProperty *sp = dynamic_cast<mitk::StringProperty *>(this->GetProperty("name"));
if (sp == nullptr)
return "";
return sp->GetValue();
}
/** Value constant that is used indicate that node names are not set so far.*/
static std::string NO_NAME_VALUE()
{
return "No Name!";
}
/**
* \brief Extra convenience access method to set the name of an object.
*
- * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
+ * If the data has already a "name" property, the name will be stored in it. Otherwise, the name will be stored in
+ * the non-renderer-specific PropertyList in a StringProperty named "name".
*/
virtual void SetName(const char *name)
{
if (name == nullptr)
return;
- this->SetProperty("name", StringProperty::New(name));
+
+ auto* data = this->GetData();
+
+ if (nullptr != data)
+ {
+ auto property = data->GetProperty("name");
+
+ if (property.IsNotNull())
+ {
+ auto* stringProperty = dynamic_cast<StringProperty*>(property.GetPointer());
+
+ if (nullptr != stringProperty)
+ {
+ stringProperty->SetValue(name);
+ return;
+ }
+ }
+ }
+
+ this->SetStringProperty("name", name);
}
/**
* \brief Extra convenience access method to set the name of an object.
*
- * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
+ * \sa SetName(const char*)
*/
- virtual void SetName(const std::string name) { this->SetName(name.c_str()); }
+ virtual void SetName(const std::string& name) { this->SetName(name.c_str()); }
/**
* \brief Convenience access method for visibility properties (instances
* of BoolProperty with property-key "visible")
* \return \a true property was found
* \sa IsVisible
*/
bool GetVisibility(bool &visible, const mitk::BaseRenderer *renderer, const char *propertyKey = "visible") const
{
return GetBoolProperty(propertyKey, visible, renderer);
}
/**
* \brief Convenience access method for opacity properties (instances of
* FloatProperty)
* \return \a true property was found
*/
bool GetOpacity(float &opacity, const mitk::BaseRenderer *renderer, const char *propertyKey = "opacity") const;
/**
* \brief Convenience access method for boolean properties (instances
* of BoolProperty). Return value is the value of the property. If the property is
* not found, the value of \a defaultIsOn is returned.
*
* Thus, the return value has a different meaning than in the
* GetBoolProperty method!
* \sa GetBoolProperty
*/
bool IsOn(const char *propertyKey, const mitk::BaseRenderer *renderer, bool defaultIsOn = true) const
{
if (propertyKey == nullptr)
return defaultIsOn;
GetBoolProperty(propertyKey, defaultIsOn, renderer);
return defaultIsOn;
}
/**
* \brief Convenience access method for visibility properties (instances
* of BoolProperty). Return value is the visibility. Default is
* visible==true, i.e., true is returned even if the property (\a
* propertyKey) is not found.
*
* Thus, the return value has a different meaning than in the
* GetVisibility method!
* \sa GetVisibility
* \sa IsOn
*/
bool IsVisible(const mitk::BaseRenderer *renderer,
const char *propertyKey = "visible",
bool defaultIsOn = true) const
{
return IsOn(propertyKey, renderer, defaultIsOn);
}
/**
* \brief Convenience method for setting color properties (instances of
* ColorProperty)
*/
void SetColor(const mitk::Color &color,
const mitk::BaseRenderer *renderer = nullptr,
const char *propertyKey = "color");
/**
* \brief Convenience method for setting color properties (instances of
* ColorProperty)
*/
void SetColor(float red,
float green,
float blue,
const mitk::BaseRenderer *renderer = nullptr,
const char *propertyKey = "color");
/**
* \brief Convenience method for setting color properties (instances of
* ColorProperty)
*/
void SetColor(const float rgb[3], const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "color");
/**
* \brief Convenience method for setting visibility properties (instances
* of BoolProperty)
* \param visible If set to true, the data will be rendered. If false, the render will skip this data.
* \param renderer Specify a renderer if the visibility shall be specific to a renderer
* \param propertyKey Can be used to specify a user defined name of the visibility propery.
*/
void SetVisibility(bool visible, const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "visible");
/**
* \brief Convenience method for setting opacity properties (instances of
* FloatProperty)
*/
void SetOpacity(float opacity, const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "opacity");
/**
* \brief Convenience method for setting level-window properties
* (instances of LevelWindowProperty)
*/
void SetLevelWindow(mitk::LevelWindow levelWindow,
const mitk::BaseRenderer *renderer = nullptr,
const char *propertyKey = "levelwindow");
/**
* \brief Convenience method for setting int properties (instances of
* IntProperty)
*/
void SetIntProperty(const char *propertyKey, int intValue, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Convenience method for setting boolean properties (instances of
* BoolProperty)
*/
void SetBoolProperty(const char *propertyKey, bool boolValue, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Convenience method for setting float properties (instances of
* FloatProperty)
*/
void SetFloatProperty(const char *propertyKey, float floatValue, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Convenience method for setting double properties (instances of
* DoubleProperty)
*/
void SetDoubleProperty(const char *propertyKey, double doubleValue, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Convenience method for setting string properties (instances of
* StringProperty)
*/
void SetStringProperty(const char *propertyKey, const char *string, const mitk::BaseRenderer *renderer = nullptr);
/**
* \brief Get the timestamp of the last change of the contents of this node or
* the referenced BaseData.
*/
itk::ModifiedTimeType GetMTime() const override;
/**
* \brief Get the timestamp of the last change of the reference to the
* BaseData.
*/
unsigned long GetDataReferenceChangedTime() const { return m_DataReferenceChangedTime.GetMTime(); }
protected:
DataNode();
~DataNode() override;
/// Invoked when the property list was modified. Calls Modified() of the DataNode
virtual void PropertyListModified(const itk::Object *caller, const itk::EventObject &event);
/// \brief Mapper-slots
mutable MapperVector m_Mappers;
/**
* \brief The data object (instance of BaseData, e.g., an Image) managed
* by this DataNode
*/
BaseData::Pointer m_Data;
/**
* \brief BaseRenderer-independent PropertyList
*
* Properties herein can be overwritten specifically for each BaseRenderer
* by the BaseRenderer-specific properties defined in m_MapOfPropertyLists.
*/
PropertyList::Pointer m_PropertyList;
/// \brief Map associating each BaseRenderer with its own PropertyList
mutable MapOfPropertyLists m_MapOfPropertyLists;
DataInteractor::Pointer m_DataInteractor;
/// \brief Timestamp of the last change of m_Data
itk::TimeStamp m_DataReferenceChangedTime;
unsigned long m_PropertyListModifiedObserverTag;
};
MITKCORE_EXPORT std::istream &operator>>(std::istream &i, DataNode::Pointer &dtn);
MITKCORE_EXPORT std::ostream &operator<<(std::ostream &o, DataNode::Pointer &dtn);
} // namespace mitk
#endif /* DATATREENODE_H_HEADER_INCLUDED_C1E14338 */
diff --git a/Modules/Core/src/IO/mitkAbstractFileReader.cpp b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
index e2f548a621..35c46b61fc 100644
--- a/Modules/Core/src/IO/mitkAbstractFileReader.cpp
+++ b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
@@ -1,334 +1,328 @@
/*============================================================================
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 <mitkAbstractFileReader.h>
#include <mitkCustomMimeType.h>
#include <mitkIOUtil.h>
#include <mitkUtf8Util.h>
#include <mitkFileReaderWriterBase.h>
#include <mitkVersion.h>
#include <mitkIOMetaInformationPropertyConstants.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usPrototypeServiceFactory.h>
#include <itksys/SystemTools.hxx>
#include <fstream>
namespace mitk
{
AbstractFileReader::InputStream::InputStream(IFileReader *reader, std::ios_base::openmode mode)
: std::istream(nullptr), m_Stream(nullptr)
{
std::istream *stream = reader->GetInputStream();
if (stream)
{
this->init(stream->rdbuf());
}
else
{
m_Stream = new std::ifstream(reader->GetInputLocation().c_str(), mode);
this->init(m_Stream->rdbuf());
}
}
AbstractFileReader::InputStream::~InputStream() { delete m_Stream; }
class AbstractFileReader::Impl : public FileReaderWriterBase
{
public:
Impl() : FileReaderWriterBase(), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
Impl(const Impl &other) : FileReaderWriterBase(other), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
std::string m_Location;
std::string m_TmpFile;
std::istream *m_Stream;
us::PrototypeServiceFactory *m_PrototypeFactory;
us::ServiceRegistration<IFileReader> m_Reg;
};
AbstractFileReader::AbstractFileReader() : d(new Impl) {}
AbstractFileReader::~AbstractFileReader()
{
UnregisterService();
delete d->m_PrototypeFactory;
if (!d->m_TmpFile.empty())
{
std::remove(d->m_TmpFile.c_str());
}
}
AbstractFileReader::AbstractFileReader(const AbstractFileReader &other) : IFileReader(), d(new Impl(*other.d.get()))
{
}
AbstractFileReader::AbstractFileReader(const CustomMimeType &mimeType, const std::string &description) : d(new Impl)
{
d->SetMimeType(mimeType);
d->SetDescription(description);
}
////////////////////// Reading /////////////////////////
std::vector<BaseData::Pointer> AbstractFileReader::Read()
{
std::vector<BaseData::Pointer> result = this->DoRead();
const auto options = this->GetOptions();
for (auto& data : result)
{
data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_DESCRIPTION()), StringProperty::New(d->GetDescription()));
data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_VERSION()), StringProperty::New(MITK_VERSION_STRING));
data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_NAME()), StringProperty::New(d->GetMimeType()->GetName()));
data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()), StringProperty::New(d->GetMimeType()->GetCategory()));
if (this->GetInputStream() == nullptr)
{
data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_INPUTLOCATION()), StringProperty::New(Utf8Util::Local8BitToUtf8(this->GetInputLocation())));
}
for (const auto& option : options)
{
auto optionpath = IOMetaInformationPropertyConstants::READER_OPTION_ROOT().AddElement(option.first);
data->SetProperty(PropertyKeyPathToPropertyName(optionpath), StringProperty::New(option.second.ToString()));
}
}
return result;
}
DataStorage::SetOfObjects::Pointer AbstractFileReader::Read(DataStorage &ds)
{
DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
std::vector<BaseData::Pointer> data = this->Read();
for (auto iter = data.begin(); iter != data.end(); ++iter)
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(*iter);
this->SetDefaultDataNodeProperties(node, this->GetInputLocation());
ds.Add(node);
result->InsertElement(result->Size(), node);
}
return result;
}
IFileReader::ConfidenceLevel AbstractFileReader::GetConfidenceLevel() const
{
if (d->m_Stream)
{
if (*d->m_Stream)
return Supported;
}
else
{
if (itksys::SystemTools::FileExists(Utf8Util::Local8BitToUtf8(this->GetInputLocation()).c_str(), true))
{
return Supported;
}
}
return Unsupported;
}
//////////// µS Registration & Properties //////////////
us::ServiceRegistration<IFileReader> AbstractFileReader::RegisterService(us::ModuleContext *context)
{
if (d->m_PrototypeFactory)
return us::ServiceRegistration<IFileReader>();
if (context == nullptr)
{
context = us::GetModuleContext();
}
d->RegisterMimeType(context);
if (this->GetMimeType()->GetName().empty())
{
MITK_WARN << "Not registering reader due to empty MIME type.";
return us::ServiceRegistration<IFileReader>();
}
struct PrototypeFactory : public us::PrototypeServiceFactory
{
AbstractFileReader *const m_Prototype;
PrototypeFactory(AbstractFileReader *prototype) : m_Prototype(prototype) {}
us::InterfaceMap GetService(us::Module * /*module*/,
const us::ServiceRegistrationBase & /*registration*/) override
{
return us::MakeInterfaceMap<IFileReader>(m_Prototype->Clone());
}
void UngetService(us::Module * /*module*/,
const us::ServiceRegistrationBase & /*registration*/,
const us::InterfaceMap &service) override
{
delete us::ExtractInterface<IFileReader>(service);
}
};
d->m_PrototypeFactory = new PrototypeFactory(this);
us::ServiceProperties props = this->GetServiceProperties();
d->m_Reg = context->RegisterService<IFileReader>(d->m_PrototypeFactory, props);
return d->m_Reg;
}
void AbstractFileReader::UnregisterService()
{
try
{
d->m_Reg.Unregister();
}
catch (const std::exception &)
{
}
}
us::ServiceProperties AbstractFileReader::GetServiceProperties() const
{
us::ServiceProperties result;
result[IFileReader::PROP_DESCRIPTION()] = this->GetDescription();
result[IFileReader::PROP_MIMETYPE()] = this->GetMimeType()->GetName();
result[us::ServiceConstants::SERVICE_RANKING()] = this->GetRanking();
return result;
}
us::ServiceRegistration<CustomMimeType> AbstractFileReader::RegisterMimeType(us::ModuleContext *context)
{
return d->RegisterMimeType(context);
}
std::vector< std::string > AbstractFileReader::GetReadFiles(){ return m_ReadFiles; }
void AbstractFileReader::SetMimeType(const CustomMimeType &mimeType) { d->SetMimeType(mimeType); }
void AbstractFileReader::SetDescription(const std::string &description) { d->SetDescription(description); }
void AbstractFileReader::SetRanking(int ranking) { d->SetRanking(ranking); }
int AbstractFileReader::GetRanking() const { return d->GetRanking(); }
std::string AbstractFileReader::GetLocalFileName() const
{
std::string localFileName;
if (d->m_Stream)
{
if (d->m_TmpFile.empty())
{
// write the stream contents to temporary file
std::string ext = Utf8Util::Utf8ToLocal8Bit(itksys::SystemTools::GetFilenameExtension(Utf8Util::Local8BitToUtf8(this->GetInputLocation())));
std::ofstream tmpStream;
localFileName = mitk::IOUtil::CreateTemporaryFile(
tmpStream, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary, "XXXXXX" + ext);
tmpStream << d->m_Stream->rdbuf();
d->m_TmpFile = localFileName;
}
else
{
localFileName = d->m_TmpFile;
}
}
else
{
localFileName = d->m_Location;
}
return localFileName;
}
//////////////////////// Options ///////////////////////
void AbstractFileReader::SetDefaultOptions(const IFileReader::Options &defaultOptions)
{
d->SetDefaultOptions(defaultOptions);
}
IFileReader::Options AbstractFileReader::GetDefaultOptions() const { return d->GetDefaultOptions(); }
void AbstractFileReader::SetInput(const std::string &location)
{
d->m_Location = location;
d->m_Stream = nullptr;
}
void AbstractFileReader::SetInput(const std::string &location, std::istream *is)
{
if (d->m_Stream != is && !d->m_TmpFile.empty())
{
std::remove(d->m_TmpFile.c_str());
d->m_TmpFile.clear();
}
d->m_Location = location;
d->m_Stream = is;
}
std::string AbstractFileReader::GetInputLocation() const { return d->m_Location; }
std::istream *AbstractFileReader::GetInputStream() const { return d->m_Stream; }
MimeType AbstractFileReader::GetRegisteredMimeType() const { return d->GetRegisteredMimeType(); }
IFileReader::Options AbstractFileReader::GetOptions() const { return d->GetOptions(); }
us::Any AbstractFileReader::GetOption(const std::string &name) const { return d->GetOption(name); }
void AbstractFileReader::SetOptions(const Options &options) { d->SetOptions(options); }
void AbstractFileReader::SetOption(const std::string &name, const us::Any &value) { d->SetOption(name, value); }
////////////////// MISC //////////////////
void AbstractFileReader::AddProgressCallback(const ProgressCallback &callback) { d->AddProgressCallback(callback); }
void AbstractFileReader::RemoveProgressCallback(const ProgressCallback &callback)
{
d->RemoveProgressCallback(callback);
}
////////////////// µS related Getters //////////////////
const CustomMimeType *AbstractFileReader::GetMimeType() const { return d->GetMimeType(); }
void AbstractFileReader::SetMimeTypePrefix(const std::string &prefix) { d->SetMimeTypePrefix(prefix); }
std::string AbstractFileReader::GetMimeTypePrefix() const { return d->GetMimeTypePrefix(); }
std::string AbstractFileReader::GetDescription() const { return d->GetDescription(); }
void AbstractFileReader::SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath)
{
// path
if (!filePath.empty())
{
auto path = itksys::SystemTools::GetFilenamePath(Utf8Util::Local8BitToUtf8(filePath));
node->SetProperty(StringProperty::PATH, mitk::StringProperty::New(path));
}
// name already defined?
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty *>(node->GetProperty("name", nullptr, false));
if (nameProp.IsNull() || nameProp->GetValue() == DataNode::NO_NAME_VALUE())
{
// name already defined in BaseData
mitk::StringProperty::Pointer baseDataNameProp =
dynamic_cast<mitk::StringProperty *>(node->GetData()->GetProperty("name").GetPointer());
if (baseDataNameProp.IsNull() || baseDataNameProp->GetValue() == DataNode::NO_NAME_VALUE())
{
// name neither defined in node, nor in BaseData -> name = filebasename;
auto name = this->GetRegisteredMimeType().GetFilenameWithoutExtension(filePath);
name = Utf8Util::Local8BitToUtf8(name);
nameProp = mitk::StringProperty::New(name);
node->SetProperty("name", nameProp);
}
- else
- {
- // name defined in BaseData!
- nameProp = mitk::StringProperty::New(baseDataNameProp->GetValue());
- node->SetProperty("name", nameProp);
- }
}
// visibility
if (!node->GetProperty("visible"))
{
node->SetVisibility(true);
}
}
}
diff --git a/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
index a877e2f8ee..bdb8eaa359 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
@@ -1,509 +1,509 @@
/*============================================================================
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 "QmitkDataStorageTableModel.h"
//# Own includes
#include "QmitkCustomVariants.h"
#include "QmitkEnums.h"
#include "mitkNodePredicateBase.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include <QmitkNodeDescriptorManager.h>
//# Toolkit includes
#include <QFile>
#include <QIcon>
#include <itkCommand.h>
//#CTORS/DTOR
QmitkDataStorageTableModel::QmitkDataStorageTableModel(mitk::DataStorage::Pointer _DataStorage,
mitk::NodePredicateBase *_Predicate,
QObject *parent)
: QAbstractTableModel(parent),
m_DataStorage(nullptr),
m_Predicate(nullptr),
m_BlockEvents(false),
m_SortDescending(false)
{
this->SetPredicate(_Predicate);
this->SetDataStorage(_DataStorage);
}
QmitkDataStorageTableModel::~QmitkDataStorageTableModel()
{
// set data storage 0 to remove event listeners
this->SetDataStorage(nullptr);
}
//# Public GETTER
const mitk::DataStorage::Pointer QmitkDataStorageTableModel::GetDataStorage() const
{
return m_DataStorage.Lock();
}
mitk::NodePredicateBase::Pointer QmitkDataStorageTableModel::GetPredicate() const
{
return m_Predicate;
}
mitk::DataNode::Pointer QmitkDataStorageTableModel::GetNode(const QModelIndex &index) const
{
mitk::DataNode::Pointer node;
if (index.isValid())
{
node = m_NodeSet.at(index.row());
}
return node;
}
QVariant QmitkDataStorageTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
QVariant headerData;
// show only horizontal header
if (role == Qt::DisplayRole)
{
if (orientation == Qt::Horizontal)
{
// first column: "Name"
if (section == 0)
headerData = "Name";
else if (section == 1)
headerData = "Data Type";
else if (section == 2)
headerData = "Visibility";
}
else if (orientation == Qt::Vertical)
{
// show numbers for rows
headerData = section + 1;
}
}
return headerData;
}
Qt::ItemFlags QmitkDataStorageTableModel::flags(const QModelIndex &index) const
{
Qt::ItemFlags flags = QAbstractItemModel::flags(index);
// name & visibility is editable
if (index.column() == 0)
{
flags |= Qt::ItemIsEditable;
}
else if (index.column() == 2)
{
flags |= Qt::ItemIsUserCheckable;
}
return flags;
}
int QmitkDataStorageTableModel::rowCount(const QModelIndex &) const
{
return m_NodeSet.size();
}
int QmitkDataStorageTableModel::columnCount(const QModelIndex &) const
{
// show name, type and visible columnn
int columns = 3;
return columns;
}
QVariant QmitkDataStorageTableModel::data(const QModelIndex &index, int role) const
{
QVariant data;
if (index.isValid() && !m_NodeSet.empty())
{
mitk::DataNode::Pointer node = m_NodeSet.at(index.row());
std::string nodeName = node->GetName();
if (nodeName.empty())
nodeName = "unnamed";
// get name
if (index.column() == 0)
{
// get name of node (may also be edited)
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
data = QString::fromStdString(nodeName);
}
else if (role == QmitkDataNodeRole)
{
data = QVariant::fromValue(node);
}
}
else if (index.column() == 1)
{
QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(node);
// get type property of mitk::BaseData
if (role == Qt::DisplayRole)
{
data = nodeDescriptor->GetNameOfClass();
}
// show some nice icons for datatype
else if (role == Qt::DecorationRole)
{
data = nodeDescriptor->GetIcon(node);
}
}
else if (index.column() == 2)
{
// get visible property of mitk::BaseData
bool visibility = false;
if (node->GetVisibility(visibility, nullptr) && role == Qt::CheckStateRole)
{
data = (visibility ? Qt::Checked : Qt::Unchecked);
} // node->GetVisibility(visibility, 0) && role == Qt::CheckStateRole
} // index.column() == 2
} // index.isValid() && !m_NodeSet.empty()
return data;
}
//# Public SETTERS
void QmitkDataStorageTableModel::SetPredicate(mitk::NodePredicateBase *_Predicate)
{
// ensure that a new predicate is set in order to avoid unnecessary changed events
if (m_Predicate != _Predicate)
{
m_Predicate = _Predicate;
this->Reset();
}
}
void QmitkDataStorageTableModel::SetDataStorage(mitk::DataStorage::Pointer _DataStorage)
{
// only proceed if we have a new datastorage
if (m_DataStorage != _DataStorage)
{
auto dataStorage = m_DataStorage.Lock();
// if a data storage was set before remove old event listeners
if (dataStorage.IsNotNull())
{
dataStorage->AddNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
this, &QmitkDataStorageTableModel::AddNode));
dataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
this, &QmitkDataStorageTableModel::RemoveNode));
}
// set new data storage
m_DataStorage = _DataStorage;
dataStorage = m_DataStorage.Lock();
// if new storage is not 0 subscribe for events
if (dataStorage.IsNotNull())
{
// subscribe for node added/removed events
dataStorage->AddNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
this, &QmitkDataStorageTableModel::AddNode));
dataStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
this, &QmitkDataStorageTableModel::RemoveNode));
}
// Reset model (even if datastorage is 0->will be checked in Reset())
this->Reset();
}
}
void QmitkDataStorageTableModel::AddNode(const mitk::DataNode *node)
{
// garantuee no recursions when a new node event is thrown
if (!m_BlockEvents)
{
// if we have a predicate, check node against predicate first
if (m_Predicate.IsNotNull() && !m_Predicate->CheckNode(node))
return;
// dont add nodes without data (formerly known as helper objects)
if (node->GetData() == nullptr)
return;
// create listener commands to listen to changes in the name or the visibility of the node
itk::MemberCommand<QmitkDataStorageTableModel>::Pointer propertyModifiedCommand =
itk::MemberCommand<QmitkDataStorageTableModel>::New();
propertyModifiedCommand->SetCallbackFunction(this, &QmitkDataStorageTableModel::PropertyModified);
mitk::BaseProperty *tempProperty = nullptr;
// add listener for properties
tempProperty = node->GetProperty("visible");
if (tempProperty)
m_VisiblePropertyModifiedObserverTags[tempProperty] =
tempProperty->AddObserver(itk::ModifiedEvent(), propertyModifiedCommand);
tempProperty = node->GetProperty("name");
if (tempProperty)
m_NamePropertyModifiedObserverTags[tempProperty] =
tempProperty->AddObserver(itk::ModifiedEvent(), propertyModifiedCommand);
// emit beginInsertRows event
beginInsertRows(QModelIndex(), m_NodeSet.size(), m_NodeSet.size());
// add node
m_NodeSet.push_back(const_cast<mitk::DataNode *>(node));
// emit endInsertRows event
endInsertRows();
}
}
void QmitkDataStorageTableModel::RemoveNode(const mitk::DataNode *node)
{
// garantuee no recursions when a new node event is thrown
if (!m_BlockEvents)
{
// find corresponding node
auto nodeIt = std::find(m_NodeSet.begin(), m_NodeSet.end(), node);
if (nodeIt != m_NodeSet.end())
{
// now: remove listeners for name property ...
mitk::BaseProperty *tempProperty = nullptr;
tempProperty = (*nodeIt)->GetProperty("visible");
if (tempProperty)
tempProperty->RemoveObserver(m_VisiblePropertyModifiedObserverTags[tempProperty]);
m_VisiblePropertyModifiedObserverTags.erase(tempProperty);
// ... and visibility property
tempProperty = (*nodeIt)->GetProperty("name");
if (tempProperty)
tempProperty->RemoveObserver(m_NamePropertyModifiedObserverTags[tempProperty]);
m_NamePropertyModifiedObserverTags.erase(tempProperty);
// get an index from iterator
int row = std::distance(m_NodeSet.begin(), nodeIt);
// emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
this->beginRemoveRows(QModelIndex(), row, row);
// remove node
m_NodeSet.erase(nodeIt);
// emit endRemoveRows event
endRemoveRows();
}
}
}
void QmitkDataStorageTableModel::PropertyModified(const itk::Object *caller, const itk::EventObject &)
{
if (!m_BlockEvents)
{
// get modified property
const mitk::BaseProperty *modifiedProperty = dynamic_cast<const mitk::BaseProperty *>(caller);
if (modifiedProperty)
{
// find node that holds the modified property
int row = -1;
int column = -1;
std::vector<mitk::DataNode *>::iterator it;
mitk::BaseProperty *visibilityProperty = nullptr;
mitk::BaseProperty *nameProperty = nullptr;
// search for property that changed and emit datachanged on the corresponding ModelIndex
for (it = m_NodeSet.begin(); it != m_NodeSet.end(); it++)
{
// check for the visible property or the name property
visibilityProperty = (*it)->GetProperty("visible");
if (modifiedProperty == visibilityProperty)
{
column = 2;
break;
}
nameProperty = (*it)->GetProperty("name");
if (modifiedProperty == nameProperty)
{
column = 0;
break;
}
}
// if we have the property we have a valid iterator
if (it != m_NodeSet.end())
row = std::distance(m_NodeSet.begin(), it);
// now emit the dataChanged signal
QModelIndex indexOfChangedProperty = index(row, column);
emit dataChanged(indexOfChangedProperty, indexOfChangedProperty);
}
}
}
bool QmitkDataStorageTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
bool noErr = false;
if (index.isValid() && (role == Qt::EditRole || role == Qt::CheckStateRole))
{
// any change events produced here should not be caught in this class
// --> set m_BlockEvents to true
m_BlockEvents = true;
mitk::DataNode::Pointer node = m_NodeSet.at(index.row());
if (index.column() == 0)
{
- node->SetStringProperty("name", value.toString().toStdString().c_str());
+ node->SetName(value.toString().toStdString());
}
else if (index.column() == 2)
{
node->SetBoolProperty("visible", (value.toInt() == Qt::Checked ? true : false));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
// inform listeners about changes
emit dataChanged(index, index);
m_BlockEvents = false;
noErr = true;
}
return noErr;
}
//#Protected SETTER
void QmitkDataStorageTableModel::Reset()
{
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet;
// remove all nodes now (dont use iterators because removing elements
// would invalidate the iterator)
// start at the last element: first in, last out
unsigned int i = m_NodeSet.size();
while (!m_NodeSet.empty())
{
--i;
this->RemoveNode(m_NodeSet.at(i));
}
// normally now everything should be empty->just to be sure
// erase all arrays again
m_NamePropertyModifiedObserverTags.clear();
m_VisiblePropertyModifiedObserverTags.clear();
m_NodeSet.clear();
auto dataStorage = m_DataStorage.Lock();
// the whole reset depends on the fact if a data storage is set or not
if (dataStorage.IsNotNull())
{
_NodeSet = m_Predicate.IsNotNull()
? dataStorage->GetSubset(m_Predicate)
: dataStorage->GetAll();
// finally add all nodes to the model
for (auto it = _NodeSet->begin(); it != _NodeSet->end(); it++)
{
// save node
this->AddNode(*it);
}
}
}
void QmitkDataStorageTableModel::sort(int column, Qt::SortOrder order /*= Qt::AscendingOrder */)
{
bool sortDescending = (order == Qt::DescendingOrder) ? true : false;
// do not sort twice !!! (dont know why, but qt calls this func twice. STUPID!)
/*
if(sortDescending != m_SortDescending)
{*/
// m_SortDescending = sortDescending;
DataNodeCompareFunction::CompareCriteria _CompareCriteria = DataNodeCompareFunction::CompareByName;
DataNodeCompareFunction::CompareOperator _CompareOperator =
sortDescending ? DataNodeCompareFunction::Greater : DataNodeCompareFunction::Less;
if (column == 1)
_CompareCriteria = DataNodeCompareFunction::CompareByClassName;
else if (column == 2)
_CompareCriteria = DataNodeCompareFunction::CompareByVisibility;
DataNodeCompareFunction compareFunc(_CompareCriteria, _CompareOperator);
std::sort(m_NodeSet.begin(), m_NodeSet.end(), compareFunc);
QAbstractTableModel::beginResetModel();
QAbstractTableModel::endResetModel();
//}
}
std::vector<mitk::DataNode *> QmitkDataStorageTableModel::GetNodeSet() const
{
return m_NodeSet;
}
QmitkDataStorageTableModel::DataNodeCompareFunction::DataNodeCompareFunction(CompareCriteria _CompareCriteria,
CompareOperator _CompareOperator)
: m_CompareCriteria(_CompareCriteria), m_CompareOperator(_CompareOperator)
{
}
bool QmitkDataStorageTableModel::DataNodeCompareFunction::operator()(const mitk::DataNode::Pointer &_Left,
const mitk::DataNode::Pointer &_Right) const
{
switch (m_CompareCriteria)
{
case CompareByClassName:
if (m_CompareOperator == Less)
return (_Left->GetData()->GetNameOfClass() < _Right->GetData()->GetNameOfClass());
else
return (_Left->GetData()->GetNameOfClass() > _Right->GetData()->GetNameOfClass());
break;
case CompareByVisibility:
{
bool _LeftVisibility = false;
bool _RightVisibility = false;
_Left->GetVisibility(_LeftVisibility, nullptr);
_Right->GetVisibility(_RightVisibility, nullptr);
if (m_CompareOperator == Less)
return (_LeftVisibility < _RightVisibility);
else
return (_LeftVisibility > _RightVisibility);
}
break;
// CompareByName:
default:
if (m_CompareOperator == Less)
return (_Left->GetName() < _Right->GetName());
else
return (_Left->GetName() > _Right->GetName());
break;
}
}
diff --git a/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
index c9e6644716..a5a56029c5 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
@@ -1,884 +1,884 @@
/*============================================================================
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 <mitkNodePredicateAnd.h>
#include <mitkNodePredicateData.h>
#include <mitkNodePredicateFirstLevel.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateProperty.h>
#include <mitkPlanarFigure.h>
#include <mitkProperties.h>
#include <mitkRenderingManager.h>
#include <mitkStringProperty.h>
#include <mitkPropertyNameHelper.h>
#include "QmitkDataStorageTreeModel.h"
#include "QmitkDataStorageTreeModelInternalItem.h"
#include "QmitkNodeDescriptorManager.h"
#include <QmitkCustomVariants.h>
#include <QmitkEnums.h>
#include <QmitkMimeTypes.h>
#include <QFile>
#include <QIcon>
#include <QMimeData>
#include <QTextStream>
#include <map>
#include <mitkCoreServices.h>
QmitkDataStorageTreeModel::QmitkDataStorageTreeModel(mitk::DataStorage *_DataStorage,
bool _PlaceNewNodesOnTop,
QObject *parent)
: QAbstractItemModel(parent),
m_DataStorage(nullptr),
m_PlaceNewNodesOnTop(_PlaceNewNodesOnTop),
m_Root(nullptr),
m_BlockDataStorageEvents(false),
m_AllowHierarchyChange(false)
{
this->SetDataStorage(_DataStorage);
}
QmitkDataStorageTreeModel::~QmitkDataStorageTreeModel()
{
// set data storage to 0 = remove all listeners
this->SetDataStorage(nullptr);
m_Root->Delete();
m_Root = nullptr;
}
mitk::DataNode::Pointer QmitkDataStorageTreeModel::GetNode(const QModelIndex &index) const
{
return this->TreeItemFromIndex(index)->GetDataNode();
}
const mitk::DataStorage::Pointer QmitkDataStorageTreeModel::GetDataStorage() const
{
return m_DataStorage.Lock();
}
QModelIndex QmitkDataStorageTreeModel::index(int row, int column, const QModelIndex &parent) const
{
TreeItem *parentItem;
if (!parent.isValid())
parentItem = m_Root;
else
parentItem = static_cast<TreeItem *>(parent.internalPointer());
TreeItem *childItem = parentItem->GetChild(row);
if (childItem)
return createIndex(row, column, childItem);
else
return QModelIndex();
}
int QmitkDataStorageTreeModel::rowCount(const QModelIndex &parent) const
{
TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
return parentTreeItem->GetChildCount();
}
Qt::ItemFlags QmitkDataStorageTreeModel::flags(const QModelIndex &index) const
{
if (index.isValid())
{
return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable |
Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
}
else
{
return Qt::ItemIsDropEnabled;
}
}
int QmitkDataStorageTreeModel::columnCount(const QModelIndex & /* parent = QModelIndex() */) const
{
return 1;
}
QModelIndex QmitkDataStorageTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
TreeItem *childItem = this->TreeItemFromIndex(index);
TreeItem *parentItem = childItem->GetParent();
if (parentItem == m_Root)
return QModelIndex();
return this->createIndex(parentItem->GetIndex(), 0, parentItem);
}
QmitkDataStorageTreeModel::TreeItem *QmitkDataStorageTreeModel::TreeItemFromIndex(const QModelIndex &index) const
{
if (index.isValid())
return static_cast<TreeItem *>(index.internalPointer());
else
return m_Root;
}
Qt::DropActions QmitkDataStorageTreeModel::supportedDropActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
Qt::DropActions QmitkDataStorageTreeModel::supportedDragActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
bool QmitkDataStorageTreeModel::dropMimeData(
const QMimeData *data, Qt::DropAction action, int row, int /*column*/, const QModelIndex &parent)
{
// Early exit, returning true, but not actually doing anything (ignoring data).
if (action == Qt::IgnoreAction)
{
return true;
}
// Note, we are returning true if we handled it, and false otherwise
bool returnValue = false;
if (data->hasFormat("application/x-qabstractitemmodeldatalist"))
{
returnValue = true;
// First we extract a Qlist of TreeItem* pointers.
QList<TreeItem *> listOfItemsToDrop = ToTreeItemPtrList(data);
if (listOfItemsToDrop.empty())
{
return false;
}
// Retrieve the TreeItem* where we are dropping stuff, and its parent.
TreeItem *dropItem = this->TreeItemFromIndex(parent);
TreeItem *parentItem = dropItem->GetParent();
// If item was dropped onto empty space, we select the root node
if (dropItem == m_Root)
{
parentItem = m_Root;
}
// Dragging and Dropping is only allowed within the same parent, so use the first item in list to validate.
// (otherwise, you could have a derived image such as a segmentation, and assign it to another image).
// NOTE: We are assuming the input list is valid... i.e. when it was dragged, all the items had the same parent.
// Determine whether or not the drag and drop operation is a valid one.
// Examples of invalid operations include:
// - dragging nodes with different parents
// - dragging nodes from one parent to another parent, if m_AllowHierarchyChange is false
// - dragging a node on one of its child nodes (only relevant if m_AllowHierarchyChange is true)
bool isValidDragAndDropOperation(true);
// different parents
{
TreeItem *firstParent = listOfItemsToDrop[0]->GetParent();
QList<TreeItem *>::iterator diIter;
for (diIter = listOfItemsToDrop.begin() + 1; diIter != listOfItemsToDrop.end(); diIter++)
{
if (firstParent != (*diIter)->GetParent())
{
isValidDragAndDropOperation = false;
break;
}
}
}
// dragging from one parent to another
if ((!m_AllowHierarchyChange) && isValidDragAndDropOperation)
{
if (row == -1) // drag onto a node
{
isValidDragAndDropOperation = listOfItemsToDrop[0]->GetParent() == parentItem;
}
else // drag between nodes
{
isValidDragAndDropOperation = listOfItemsToDrop[0]->GetParent() == dropItem;
}
}
// dragging on a child node of one the dragged nodes
{
QList<TreeItem *>::iterator diIter;
for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
{
TreeItem *tempItem = dropItem;
while (tempItem != m_Root)
{
tempItem = tempItem->GetParent();
if (tempItem == *diIter)
{
isValidDragAndDropOperation = false;
}
}
}
}
if (!isValidDragAndDropOperation)
return isValidDragAndDropOperation;
if (listOfItemsToDrop[0] != dropItem && isValidDragAndDropOperation)
{
// Retrieve the index of where we are dropping stuff.
QModelIndex parentModelIndex = this->IndexFromTreeItem(parentItem);
int dragIndex = 0;
// Iterate through the list of TreeItem (which may be at non-consecutive indexes).
QList<TreeItem *>::iterator diIter;
for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
{
TreeItem *itemToDrop = *diIter;
// if the item is dragged down we have to compensate its final position for the
// fact it is deleted lateron, this only applies if it is dragged within the same level
if ((itemToDrop->GetIndex() < row) && (itemToDrop->GetParent() == dropItem))
{
dragIndex = 1;
}
// Here we assume that as you remove items, one at a time, that GetIndex() will be valid.
this->beginRemoveRows(
this->IndexFromTreeItem(itemToDrop->GetParent()), itemToDrop->GetIndex(), itemToDrop->GetIndex());
itemToDrop->GetParent()->RemoveChild(itemToDrop);
this->endRemoveRows();
}
// row = -1 dropped on an item, row != -1 dropped in between two items
// Select the target index position, or put it at the end of the list.
int dropIndex = 0;
if (row != -1)
{
if (dragIndex == 0)
dropIndex = std::min(row, parentItem->GetChildCount() - 1);
else
dropIndex = std::min(row - 1, parentItem->GetChildCount() - 1);
}
else
{
dropIndex = dropItem->GetIndex();
}
QModelIndex dropItemModelIndex = this->IndexFromTreeItem(dropItem);
if ((row == -1 && dropItemModelIndex.row() == -1) || dropItemModelIndex.row() > parentItem->GetChildCount())
dropIndex = parentItem->GetChildCount() - 1;
// Now insert items again at the drop item position
if (m_AllowHierarchyChange)
{
this->beginInsertRows(dropItemModelIndex, dropIndex, dropIndex + listOfItemsToDrop.size() - 1);
}
else
{
this->beginInsertRows(parentModelIndex, dropIndex, dropIndex + listOfItemsToDrop.size() - 1);
}
for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
{
// dropped on node, behaviour depends on preference setting
if (m_AllowHierarchyChange)
{
auto dataStorage = m_DataStorage.Lock();
m_BlockDataStorageEvents = true;
mitk::DataNode::Pointer droppedNode = (*diIter)->GetDataNode();
mitk::DataNode *dropOntoNode = dropItem->GetDataNode();
dataStorage->Remove(droppedNode);
dataStorage->Add(droppedNode, dropOntoNode);
m_BlockDataStorageEvents = false;
dropItem->InsertChild((*diIter), dropIndex);
}
else
{
if (row == -1) // drag onto a node
{
parentItem->InsertChild((*diIter), dropIndex);
}
else // drag between nodes
{
dropItem->InsertChild((*diIter), dropIndex);
}
}
dropIndex++;
}
this->endInsertRows();
// Change Layers to match.
this->AdjustLayerProperty();
}
}
else if (data->hasFormat("application/x-mitk-datanodes"))
{
returnValue = true;
int numberOfNodesDropped = 0;
QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
mitk::DataNode *node = nullptr;
foreach (node, dataNodeList)
{
auto datastorage = m_DataStorage.Lock();
if (node && datastorage.IsNotNull() && !datastorage->Exists(node))
{
m_DataStorage.Lock()->Add(node);
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(basedata->GetTimeGeometry());
numberOfNodesDropped++;
}
}
}
// Only do a rendering update, if we actually dropped anything.
if (numberOfNodesDropped > 0)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
return returnValue;
}
QStringList QmitkDataStorageTreeModel::mimeTypes() const
{
QStringList types = QAbstractItemModel::mimeTypes();
types << "application/x-qabstractitemmodeldatalist";
types << "application/x-mitk-datanodes";
return types;
}
QMimeData *QmitkDataStorageTreeModel::mimeData(const QModelIndexList &indexes) const
{
return mimeDataFromModelIndexList(indexes);
}
QMimeData *QmitkDataStorageTreeModel::mimeDataFromModelIndexList(const QModelIndexList &indexes)
{
QMimeData *ret = new QMimeData;
QString treeItemAddresses("");
QString dataNodeAddresses("");
QByteArray baTreeItemPtrs;
QByteArray baDataNodePtrs;
QDataStream dsTreeItemPtrs(&baTreeItemPtrs, QIODevice::WriteOnly);
QDataStream dsDataNodePtrs(&baDataNodePtrs, QIODevice::WriteOnly);
for (int i = 0; i < indexes.size(); i++)
{
TreeItem *treeItem = static_cast<TreeItem *>(indexes.at(i).internalPointer());
dsTreeItemPtrs << reinterpret_cast<quintptr>(treeItem);
dsDataNodePtrs << reinterpret_cast<quintptr>(treeItem->GetDataNode().GetPointer());
// --------------- deprecated -----------------
unsigned long long treeItemAddress = reinterpret_cast<unsigned long long>(treeItem);
unsigned long long dataNodeAddress = reinterpret_cast<unsigned long long>(treeItem->GetDataNode().GetPointer());
QTextStream(&treeItemAddresses) << treeItemAddress;
QTextStream(&dataNodeAddresses) << dataNodeAddress;
if (i != indexes.size() - 1)
{
QTextStream(&treeItemAddresses) << ",";
QTextStream(&dataNodeAddresses) << ",";
}
// -------------- end deprecated -------------
}
// ------------------ deprecated -----------------
ret->setData("application/x-qabstractitemmodeldatalist", QByteArray(treeItemAddresses.toLatin1()));
ret->setData("application/x-mitk-datanodes", QByteArray(dataNodeAddresses.toLatin1()));
// --------------- end deprecated -----------------
ret->setData(QmitkMimeTypes::DataStorageTreeItemPtrs, baTreeItemPtrs);
ret->setData(QmitkMimeTypes::DataNodePtrs, baDataNodePtrs);
return ret;
}
QVariant QmitkDataStorageTreeModel::data(const QModelIndex &index, int role) const
{
mitk::DataNode *dataNode = this->TreeItemFromIndex(index)->GetDataNode();
// get name of treeItem (may also be edited)
QString nodeName = QString::fromStdString(dataNode->GetName());
if (nodeName.isEmpty())
{
nodeName = "unnamed";
}
if (role == Qt::DisplayRole)
return nodeName;
else if (role == Qt::ToolTipRole)
return nodeName;
else if (role == Qt::DecorationRole)
{
QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
return nodeDescriptor->GetIcon(dataNode);
}
else if (role == Qt::CheckStateRole)
{
return dataNode->IsVisible(nullptr);
}
else if (role == QmitkDataNodeRole)
{
return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
}
else if (role == QmitkDataNodeRawPointerRole)
{
return QVariant::fromValue<mitk::DataNode *>(dataNode);
}
return QVariant();
}
bool QmitkDataStorageTreeModel::DicomPropertiesExists(const mitk::DataNode &node) const
{
bool propertiesExists = false;
mitk::BaseProperty *seriesDescription_deprecated = (node.GetProperty("dicom.series.SeriesDescription"));
mitk::BaseProperty *studyDescription_deprecated = (node.GetProperty("dicom.study.StudyDescription"));
mitk::BaseProperty *patientsName_deprecated = (node.GetProperty("dicom.patient.PatientsName"));
mitk::BaseProperty *seriesDescription =
(node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x103e).c_str()));
mitk::BaseProperty *studyDescription =
(node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x1030).c_str()));
mitk::BaseProperty *patientsName = (node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str()));
if (patientsName != nullptr && studyDescription != nullptr && seriesDescription != nullptr)
{
if ((!patientsName->GetValueAsString().empty()) && (!studyDescription->GetValueAsString().empty()) &&
(!seriesDescription->GetValueAsString().empty()))
{
propertiesExists = true;
}
}
/** Code coveres the deprecated property naming for backwards compatibility */
if (patientsName_deprecated != nullptr && studyDescription_deprecated != nullptr && seriesDescription_deprecated != nullptr)
{
if ((!patientsName_deprecated->GetValueAsString().empty()) &&
(!studyDescription_deprecated->GetValueAsString().empty()) &&
(!seriesDescription_deprecated->GetValueAsString().empty()))
{
propertiesExists = true;
}
}
return propertiesExists;
}
QVariant QmitkDataStorageTreeModel::headerData(int /*section*/, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
return QString::fromStdString(m_Root->GetDataNode()->GetName());
return QVariant();
}
void QmitkDataStorageTreeModel::SetDataStorage(mitk::DataStorage *_DataStorage)
{
if (m_DataStorage != _DataStorage) // dont take the same again
{
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNotNull())
{
// remove Listener for the data storage itself
dataStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove listeners for the nodes
dataStorage->AddNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(this,
&QmitkDataStorageTreeModel::AddNode));
dataStorage->ChangedNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
this, &QmitkDataStorageTreeModel::SetNodeModified));
dataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
this, &QmitkDataStorageTreeModel::RemoveNode));
}
this->beginResetModel();
// take over the new data storage
m_DataStorage = _DataStorage;
// delete the old root (if necessary, create new)
if (m_Root)
m_Root->Delete();
mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
rootDataNode->SetName("Data Manager");
m_Root = new TreeItem(rootDataNode, nullptr);
dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNotNull())
{
// add Listener for the data storage itself
auto command = itk::SimpleMemberCommand<QmitkDataStorageTreeModel>::New();
command->SetCallbackFunction(this, &QmitkDataStorageTreeModel::SetDataStorageDeleted);
m_DataStorageDeletedTag = dataStorage->AddObserver(itk::DeleteEvent(), command);
// add listeners for the nodes
dataStorage->AddNodeEvent.AddListener(mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
this, &QmitkDataStorageTreeModel::AddNode));
dataStorage->ChangedNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
this, &QmitkDataStorageTreeModel::SetNodeModified));
dataStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
this, &QmitkDataStorageTreeModel::RemoveNode));
// finally add all nodes to the model
this->Update();
}
this->endResetModel();
}
}
void QmitkDataStorageTreeModel::SetDataStorageDeleted()
{
this->SetDataStorage(nullptr);
}
void QmitkDataStorageTreeModel::AddNodeInternal(const mitk::DataNode *node)
{
auto dataStorage = m_DataStorage.Lock();
if (node == nullptr || dataStorage.IsNull() || !dataStorage->Exists(node) || m_Root->Find(node) != nullptr)
return;
// find out if we have a root node
TreeItem *parentTreeItem = m_Root;
QModelIndex index;
mitk::DataNode *parentDataNode = this->GetParentNode(node);
if (parentDataNode) // no top level data node
{
parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
if (!parentTreeItem)
{
this->AddNode(parentDataNode);
parentTreeItem = m_Root->Find(parentDataNode);
if (!parentTreeItem)
return;
}
// get the index of this parent with the help of the grand parent
index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
}
// add node
if (m_PlaceNewNodesOnTop)
{
// emit beginInsertRows event
beginInsertRows(index, 0, 0);
parentTreeItem->InsertChild(new TreeItem(const_cast<mitk::DataNode *>(node)), 0);
}
else
{
int firstRowWithASiblingBelow = 0;
int nodeLayer = -1;
node->GetIntProperty("layer", nodeLayer);
for (TreeItem* siblingTreeItem: parentTreeItem->GetChildren())
{
int siblingLayer = -1;
if (mitk::DataNode* siblingNode = siblingTreeItem->GetDataNode())
{
siblingNode->GetIntProperty("layer", siblingLayer);
}
if (nodeLayer > siblingLayer)
{
break;
}
++firstRowWithASiblingBelow;
}
beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
parentTreeItem->InsertChild(new TreeItem(const_cast<mitk::DataNode*>(node)), firstRowWithASiblingBelow);
}
// emit endInsertRows event
endInsertRows();
if(m_PlaceNewNodesOnTop)
{
this->AdjustLayerProperty();
}
}
void QmitkDataStorageTreeModel::AddNode(const mitk::DataNode *node)
{
auto dataStorage = m_DataStorage.Lock();
if (node == nullptr || m_BlockDataStorageEvents || dataStorage.IsNull() || !dataStorage->Exists(node) ||
m_Root->Find(node) != nullptr)
return;
this->AddNodeInternal(node);
}
void QmitkDataStorageTreeModel::SetPlaceNewNodesOnTop(bool _PlaceNewNodesOnTop)
{
m_PlaceNewNodesOnTop = _PlaceNewNodesOnTop;
}
void QmitkDataStorageTreeModel::RemoveNodeInternal(const mitk::DataNode *node)
{
if (!m_Root)
return;
TreeItem *treeItem = m_Root->Find(node);
if (!treeItem)
return; // return because there is no treeitem containing this node
TreeItem *parentTreeItem = treeItem->GetParent();
QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);
// emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());
// remove node
std::vector<TreeItem*> children = treeItem->GetChildren();
delete treeItem;
// emit endRemoveRows event
endRemoveRows();
// move all children of deleted node into its parent
for (std::vector<TreeItem*>::iterator it = children.begin(); it != children.end(); it++)
{
// emit beginInsertRows event
beginInsertRows(parentIndex, parentTreeItem->GetChildCount(), parentTreeItem->GetChildCount());
// add nodes again
parentTreeItem->AddChild(*it);
// emit endInsertRows event
endInsertRows();
}
this->AdjustLayerProperty();
}
void QmitkDataStorageTreeModel::RemoveNode(const mitk::DataNode *node)
{
if (node == nullptr || m_BlockDataStorageEvents)
return;
this->RemoveNodeInternal(node);
}
void QmitkDataStorageTreeModel::SetNodeModified(const mitk::DataNode *node)
{
TreeItem *treeItem = m_Root->Find(node);
if (treeItem)
{
TreeItem *parentTreeItem = treeItem->GetParent();
// as the root node should not be removed one should always have a parent item
if (!parentTreeItem)
return;
QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);
// now emit the dataChanged signal
emit dataChanged(index, index);
}
}
mitk::DataNode *QmitkDataStorageTreeModel::GetParentNode(const mitk::DataNode *node) const
{
mitk::DataNode *dataNode = nullptr;
mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage.Lock()->GetSources(node);
if (_Sources->Size() > 0)
dataNode = _Sources->front();
return dataNode;
}
bool QmitkDataStorageTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
mitk::DataNode *dataNode = this->TreeItemFromIndex(index)->GetDataNode();
if (!dataNode)
return false;
if (role == Qt::EditRole && !value.toString().isEmpty())
{
- dataNode->SetStringProperty("name", value.toString().toStdString().c_str());
+ dataNode->SetName(value.toString().toStdString());
mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(dataNode->GetData());
if (planarFigure != nullptr)
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else if (role == Qt::CheckStateRole)
{
// Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
// Therefore the checkstate is being estimated again here.
QVariant qcheckstate = index.data(Qt::CheckStateRole);
int checkstate = qcheckstate.toInt();
bool isVisible = bool(checkstate);
dataNode->SetVisibility(!isVisible);
emit nodeVisibilityChanged();
}
// inform listeners about changes
emit dataChanged(index, index);
return true;
}
bool QmitkDataStorageTreeModel::setHeaderData(int /*section*/,
Qt::Orientation /*orientation*/,
const QVariant & /* value */,
int /*role = Qt::EditRole*/)
{
return false;
}
void QmitkDataStorageTreeModel::AdjustLayerProperty()
{
/// transform the tree into an array and set the layer property descending
std::vector<TreeItem *> vec;
this->TreeToVector(m_Root, vec);
int i = vec.size() - 1;
for (std::vector<TreeItem *>::const_iterator it = vec.begin(); it != vec.end(); ++it)
{
mitk::DataNode::Pointer dataNode = (*it)->GetDataNode();
bool fixedLayer = false;
if (!(dataNode->GetBoolProperty("fixedLayer", fixedLayer) && fixedLayer))
dataNode->SetIntProperty("layer", i);
--i;
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataStorageTreeModel::TreeToVector(TreeItem *parent, std::vector<TreeItem *> &vec) const
{
TreeItem *current;
for (int i = 0; i < parent->GetChildCount(); ++i)
{
current = parent->GetChild(i);
this->TreeToVector(current, vec);
vec.push_back(current);
}
}
QModelIndex QmitkDataStorageTreeModel::IndexFromTreeItem(TreeItem *item) const
{
if (item == m_Root)
return QModelIndex();
else
return this->createIndex(item->GetIndex(), 0, item);
}
QList<mitk::DataNode::Pointer> QmitkDataStorageTreeModel::GetNodeSet() const
{
QList<mitk::DataNode::Pointer> res;
if (m_Root)
this->TreeToNodeSet(m_Root, res);
return res;
}
void QmitkDataStorageTreeModel::TreeToNodeSet(TreeItem *parent, QList<mitk::DataNode::Pointer> &vec) const
{
TreeItem *current;
for (int i = 0; i < parent->GetChildCount(); ++i)
{
current = parent->GetChild(i);
vec.push_back(current->GetDataNode());
this->TreeToNodeSet(current, vec);
}
}
QModelIndex QmitkDataStorageTreeModel::GetIndex(const mitk::DataNode *node) const
{
if (m_Root)
{
TreeItem *item = m_Root->Find(node);
if (item)
return this->IndexFromTreeItem(item);
}
return QModelIndex();
}
QList<QmitkDataStorageTreeModel::TreeItem *> QmitkDataStorageTreeModel::ToTreeItemPtrList(const QMimeData *mimeData)
{
if (mimeData == nullptr || !mimeData->hasFormat(QmitkMimeTypes::DataStorageTreeItemPtrs))
{
return QList<TreeItem *>();
}
return ToTreeItemPtrList(mimeData->data(QmitkMimeTypes::DataStorageTreeItemPtrs));
}
QList<QmitkDataStorageTreeModel::TreeItem *> QmitkDataStorageTreeModel::ToTreeItemPtrList(const QByteArray &ba)
{
QList<TreeItem *> result;
QDataStream ds(ba);
while (!ds.atEnd())
{
quintptr treeItemPtr;
ds >> treeItemPtr;
result.push_back(reinterpret_cast<TreeItem *>(treeItemPtr));
}
return result;
}
void QmitkDataStorageTreeModel::Update()
{
auto datastorage = m_DataStorage.Lock();
if (datastorage.IsNotNull())
{
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = datastorage->GetAll();
/// Regardless the value of this preference, the new nodes must not be inserted
/// at the top now, but at the position according to their layer.
bool newNodesWereToBePlacedOnTop = m_PlaceNewNodesOnTop;
m_PlaceNewNodesOnTop = false;
for (const auto& node : *_NodeSet)
{
this->AddNodeInternal(node);
}
m_PlaceNewNodesOnTop = newNodesWereToBePlacedOnTop;
/// Adjust the layers to ensure that derived nodes are above their sources.
this->AdjustLayerProperty();
}
}
void QmitkDataStorageTreeModel::SetAllowHierarchyChange(bool allowHierarchyChange)
{
m_AllowHierarchyChange = allowHierarchyChange;
}