diff --git a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp
index a3765d5512..37bd09a818 100644
--- a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp
+++ b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp
@@ -1,326 +1,339 @@
/*============================================================================
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 "mitkMultiLabelSegmentationVtkMapper3D.h"
// MITK
#include <mitkDataNode.h>
#include <mitkProperties.h>
#include <mitkVectorProperty.h>
// MITK Rendering
// VTK
#include <vtkImageData.h>
#include <vtkLookupTable.h>
#include <vtkVolume.h>
#include <vtkSmartVolumeMapper.h>
#include <vtkVolumeProperty.h>
#include <vtkSmartPointer.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
-#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
namespace
{
itk::ModifiedTimeType PropertyTimeStampIsNewer(const mitk::IPropertyProvider* provider, mitk::BaseRenderer* renderer, const std::string& propName, itk::ModifiedTimeType refMT)
{
const std::string context = renderer != nullptr ? renderer->GetName() : "";
auto prop = provider->GetConstProperty(propName, context);
if (prop != nullptr)
{
return prop->GetTimeStamp() > refMT;
}
return false;
}
}
mitk::MultiLabelSegmentationVtkMapper3D::MultiLabelSegmentationVtkMapper3D()
{
}
mitk::MultiLabelSegmentationVtkMapper3D::~MultiLabelSegmentationVtkMapper3D()
{
}
vtkProp *mitk::MultiLabelSegmentationVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
// return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actors;
}
mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage *mitk::MultiLabelSegmentationVtkMapper3D::GetLocalStorage(
mitk::BaseRenderer *renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
void mitk::MultiLabelSegmentationVtkMapper3D::GenerateLookupTable(mitk::BaseRenderer* renderer)
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
mitk::DataNode* node = this->GetDataNode();
auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
assert(image && image->IsInitialized());
localStorage->m_LabelLookupTable = image->GetLookupTable()->Clone();
auto lookUpTable = localStorage->m_LabelLookupTable->GetVtkLookupTable();
const auto labelValues = image->GetAllLabelValues();
std::string propertyName = "org.mitk.multilabel.labels.highlighted";
mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
if (nullptr != prop)
{
const auto highlightedLabelValues = prop->GetValue();
if (!highlightedLabelValues.empty())
{
auto highlightEnd = highlightedLabelValues.cend();
double rgba[4];
for (const auto& value : labelValues)
{
lookUpTable->GetTableValue(value, rgba);
if (highlightEnd == std::find(highlightedLabelValues.begin(), highlightedLabelValues.end(), value))
{ //make all none highlighted values more transparent
rgba[3] *= 0.05;
}
else if (rgba[3] != 0)
{ //if highlighted values are visible set them to opaque to pop out
rgba[3] = 1.;
}
lookUpTable->SetTableValue(value, rgba);
}
localStorage->m_LabelLookupTable->Modified(); // need to call modified, since LookupTableProperty seems to be unchanged so no widget-update is
// executed
}
}
- localStorage->m_TransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
- localStorage->m_OpacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
+ for (int lidx = 0; lidx < image->GetNumberOfLayers(); ++lidx)
+ {
+ localStorage->m_TransferFunctions[lidx] = vtkSmartPointer<vtkColorTransferFunction>::New();
+ localStorage->m_OpacityTransferFunctions[lidx] = vtkSmartPointer<vtkPiecewiseFunction>::New();
- localStorage->m_TransferFunction->AddRGBPoint(0, 0., 0., 1.);
- localStorage->m_OpacityTransferFunction->AddPoint(0, 0.);
+ localStorage->m_TransferFunctions[lidx]->AddRGBPoint(0, 0., 0., 1.);
+ localStorage->m_OpacityTransferFunctions[lidx]->AddPoint(0, 0.);
- for (const auto& value : labelValues)
- {
- double* color = lookUpTable->GetTableValue(value);
- localStorage->m_TransferFunction->AddRGBPoint(value, color[0], color[1], color[2]);
+ for (const auto& value : image->GetLabelValuesByGroup(lidx))
+ {
+ double* color = lookUpTable->GetTableValue(value);
+ localStorage->m_TransferFunctions[lidx]->AddRGBPoint(value, color[0], color[1], color[2]);
- localStorage->m_OpacityTransferFunction->AddPoint(value, color[3]);
+ localStorage->m_OpacityTransferFunctions[lidx]->AddPoint(value, color[3]);
+ }
}
}
namespace
{
std::vector<mitk::LabelSetImage::GroupIndexType> GetOutdatedGroups(const mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage* ls, const mitk::LabelSetImage* seg)
{
const auto nrOfGroups = seg->GetNumberOfLayers();
std::vector<mitk::LabelSetImage::GroupIndexType> result;
for (mitk::LabelSetImage::GroupIndexType groupID = 0; groupID < nrOfGroups; ++groupID)
{
const auto groupImage = seg->GetGroupImage(groupID);
if (groupImage->GetMTime() > ls->m_LastDataUpdateTime
|| groupImage->GetPipelineMTime() > ls->m_LastDataUpdateTime
|| ls->m_GroupImageIDs.size() <= groupID
|| groupImage != ls->m_GroupImageIDs[groupID])
{
result.push_back(groupID);
}
}
return result;
}
}
void mitk::MultiLabelSegmentationVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::DataNode *node = this->GetDataNode();
auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
assert(image && image->IsInitialized());
bool isLookupModified = localStorage->m_LabelLookupTable.IsNull() ||
(localStorage->m_LabelLookupTable->GetMTime() < image->GetLookupTable()->GetMTime()) ||
PropertyTimeStampIsNewer(node, renderer, "org.mitk.multilabel.labels.highlighted", localStorage->m_LabelLookupTable->GetMTime());
- if (isLookupModified)
- {
- this->GenerateLookupTable(renderer);
- }
-
auto outdatedGroups = GetOutdatedGroups(localStorage, image);
bool isGeometryModified = (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
(localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime());
if (isGeometryModified)
{
//if geometry is outdated all groups need regeneration
outdatedGroups.resize(image->GetNumberOfLayers());
std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
}
if (!outdatedGroups.empty())
{
auto hasValidContent = this->GenerateVolumeMapping(renderer, outdatedGroups);
if (!hasValidContent) return;
}
- float opacity = 1.0f;
- node->GetOpacity(opacity, renderer, "opacity");
+ if (isLookupModified)
+ {
+ this->GenerateLookupTable(renderer);
+ }
if (isLookupModified)
{
//if lookup table is modified all groups need a new color mapping
outdatedGroups.resize(image->GetNumberOfLayers());
std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
}
for (const auto groupID : outdatedGroups)
{
- localStorage->m_LayerVolumeProperties[groupID]->SetColor(localStorage->m_TransferFunction);
- localStorage->m_LayerVolumeProperties[groupID]->SetScalarOpacity(localStorage->m_OpacityTransferFunction);
- localStorage->m_LayerVolumes[groupID]->SetMapper(localStorage->m_LayerVolumeMappers[groupID]);
- localStorage->m_LayerVolumes[groupID]->SetProperty(localStorage->m_LayerVolumeProperties[groupID]);
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetColor(localStorage->m_TransferFunctions[groupID]);
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetScalarOpacity(localStorage->m_OpacityTransferFunctions[groupID]);
+ localStorage->m_LayerVolumes[groupID]->Update();
}
}
bool mitk::MultiLabelSegmentationVtkMapper3D::GenerateVolumeMapping(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs)
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
mitk::DataNode* node = this->GetDataNode();
auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
assert(image && image->IsInitialized());
image->Update();
const auto numberOfLayers = image->GetNumberOfLayers();
if (numberOfLayers != localStorage->m_NumberOfLayers)
{
if (numberOfLayers > localStorage->m_NumberOfLayers)
{
for (int lidx = localStorage->m_NumberOfLayers; lidx < numberOfLayers; ++lidx)
{
localStorage->m_GroupImageIDs.push_back(nullptr);
localStorage->m_LayerImages.push_back(vtkSmartPointer<vtkImageData>::New());
localStorage->m_LayerVolumeMappers.push_back(vtkSmartPointer<vtkSmartVolumeMapper>::New());
- localStorage->m_LayerVolumeProperties.push_back(vtkSmartPointer<vtkVolumeProperty>::New());
localStorage->m_LayerVolumes.push_back(vtkSmartPointer<vtkVolume>::New());
+
+ localStorage->m_TransferFunctions.push_back(vtkSmartPointer<vtkColorTransferFunction>::New());
+ localStorage->m_OpacityTransferFunctions.push_back(vtkSmartPointer<vtkPiecewiseFunction>::New());
}
}
else
{
localStorage->m_GroupImageIDs.resize(numberOfLayers);
localStorage->m_LayerImages.resize(numberOfLayers);
localStorage->m_LayerVolumeMappers.resize(numberOfLayers);
- localStorage->m_LayerVolumeProperties.resize(numberOfLayers);
localStorage->m_LayerVolumes.resize(numberOfLayers);
+
+ localStorage->m_TransferFunctions.resize(numberOfLayers);
+ localStorage->m_OpacityTransferFunctions.resize(numberOfLayers);
}
localStorage->m_NumberOfLayers = numberOfLayers;
localStorage->m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
for (int lidx = 0; lidx < numberOfLayers; ++lidx)
{
localStorage->m_Actors->AddPart(localStorage->m_LayerVolumes[lidx]);
}
}
for (const auto groupID : outdatedGroupIDs)
{
const auto groupImage = image->GetGroupImage(groupID);
localStorage->m_GroupImageIDs[groupID] = groupImage;
localStorage->m_LayerImages[groupID] = groupImage->GetVtkImageData(this->GetTimestep());
+
+ //need to recreate the volumeMapper because otherwise label data was still rendered even
+ //if a label was removed. There must be a cleaner way to do it. Exchanging the whole mapper
+ //is a ugly workaround for now.
+ localStorage->m_LayerVolumeMappers[groupID] = vtkSmartPointer<vtkSmartVolumeMapper>::New();
+
localStorage->m_LayerVolumeMappers[groupID]->SetInputData(localStorage->m_LayerImages[groupID]);
- localStorage->m_LayerVolumeProperties[groupID]->ShadeOff();
- localStorage->m_LayerVolumeProperties[groupID]->SetInterpolationTypeToNearest();
+
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->ShadeOn();
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetDiffuse(1.0);
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetAmbient(0.4);
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetSpecular(0.2);
+ localStorage->m_LayerVolumes[groupID]->GetProperty()->SetInterpolationTypeToNearest();
+
+ localStorage->m_LayerVolumes[groupID]->SetMapper(localStorage->m_LayerVolumeMappers[groupID]);
}
localStorage->m_LastDataUpdateTime.Modified();
return true;
}
void mitk::MultiLabelSegmentationVtkMapper3D::Update(mitk::BaseRenderer *renderer)
{
bool visible = true;
+ bool has3Dvisualize = true;
const DataNode *node = this->GetDataNode();
node->GetVisibility(visible, renderer, "visible");
+ node->GetBoolProperty("multilabel.3D.visualize", has3Dvisualize, renderer);
if (!visible)
return;
auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
if (image == nullptr || image->IsInitialized() == false)
return;
// Calculate time step of the image data for the specified renderer (integer value)
this->CalculateTimeStep(renderer);
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = image->GetTimeGeometry();
if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
(!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
{
return;
}
image->UpdateOutputInformation();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// check if something important has changed and we need to re-render
if (localStorage->m_LabelLookupTable.IsNull() ||
(localStorage->m_LabelLookupTable->GetMTime() < image->GetLookupTable()->GetMTime()) ||
(localStorage->m_LastDataUpdateTime < image->GetMTime()) ||
(localStorage->m_LastDataUpdateTime < image->GetPipelineMTime()) ||
(localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
(localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
(localStorage->m_LastPropertyUpdateTime < node->GetPropertyList()->GetMTime()) ||
(localStorage->m_LastPropertyUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
(localStorage->m_LastPropertyUpdateTime < image->GetPropertyList()->GetMTime()))
{
this->GenerateDataForRenderer(renderer);
localStorage->m_LastPropertyUpdateTime.Modified();
}
}
void mitk::MultiLabelSegmentationVtkMapper3D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
- // add/replace the following properties
- node->SetProperty("opacity", FloatProperty::New(1.0f), renderer);
-
- node->SetProperty("labelset.contour.active", BoolProperty::New(true), renderer);
- node->SetProperty("labelset.contour.width", FloatProperty::New(2.0), renderer);
-
Superclass::SetDefaultProperties(node, renderer, overwrite);
+
+ // add/replace the following properties
+ node->SetProperty("multilabel.3D.visualize", BoolProperty::New(true), renderer);
}
mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage::~LocalStorage()
{
}
mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage::LocalStorage()
{
// Do as much actions as possible in here to avoid double executions.
m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
m_NumberOfLayers = 0;
}
diff --git a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h
index 4d9aefeec1..450b8c7e6e 100644
--- a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h
+++ b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h
@@ -1,149 +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.
============================================================================*/
#ifndef mitkMultiLabelSegmentationVtkMapper3D_h
#define mitkMultiLabelSegmentationVtkMapper3D_h
// MITK
#include "MitkMultilabelExports.h"
#include "mitkCommon.h"
// MITK Rendering
#include "mitkBaseRenderer.h"
#include "mitkExtractSliceFilter.h"
#include "mitkLabelSetImage.h"
#include "mitkVtkMapper.h"
// VTK
#include <vtkSmartPointer.h>
class vtkPolyDataMapper;
class vtkImageData;
class vtkLookupTable;
class vtkVolumeProperty;
class vtkVolume;
class vtkSmartVolumeMapper;
namespace mitk
{
/** \brief Mapper to resample and display 2D slices of a 3D labelset image.
*
* Properties that can be set for labelset images and influence this mapper are:
*
* - \b "labelset.contour.active": (BoolProperty) whether to show only the active label as a contour or not
* - \b "labelset.contour.width": (FloatProperty) line width of the contour
* The default properties are:
* - \b "labelset.contour.active", mitk::BoolProperty::New( true ), renderer, overwrite )
* - \b "labelset.contour.width", mitk::FloatProperty::New( 2.0 ), renderer, overwrite )
* \ingroup Mapper
*/
class MITKMULTILABEL_EXPORT MultiLabelSegmentationVtkMapper3D : public VtkMapper
{
public:
/** Standard class typedefs. */
mitkClassMacro(MultiLabelSegmentationVtkMapper3D, VtkMapper);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \brief Checks whether this mapper needs to update itself and generate
* data. */
void Update(mitk::BaseRenderer *renderer) override;
//### methods of MITK-VTK rendering pipeline
vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
//### end of methods of MITK-VTK rendering pipeline
/** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
/**
* To render axial, coronal, and sagittal, the mapper is called three times.
* For performance reasons, the corresponding data for each view is saved in the
* internal helper class LocalStorage. This allows rendering n views with just
* 1 mitkMapper using n vtkMapper.
* */
class MITKMULTILABEL_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
vtkSmartPointer<vtkPropAssembly> m_Actors;
std::vector<vtkSmartPointer<vtkSmartVolumeMapper>> m_LayerVolumeMappers;
std::vector<vtkSmartPointer<vtkImageData>> m_LayerImages;
std::vector<vtkSmartPointer<vtkVolume>> m_LayerVolumes;
- std::vector<vtkSmartPointer<vtkVolumeProperty>> m_LayerVolumeProperties;
+
+ std::vector <vtkSmartPointer<vtkColorTransferFunction> > m_TransferFunctions;
+ std::vector <vtkSmartPointer<vtkPiecewiseFunction> > m_OpacityTransferFunctions;
/** Vector containing the pointer of the currently used group images.
* IMPORTANT: This member must not be used to access any data.
* Its purpose is to allow checking if the order of the groups has changed
* in order to adapt the pipe line accordingly*/
std::vector<const Image*> m_GroupImageIDs;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastDataUpdateTime;
/** \brief Timestamp of last update of a property. */
itk::TimeStamp m_LastPropertyUpdateTime;
/** look up table for label colors. */
mitk::LookupTable::Pointer m_LabelLookupTable;
- vtkSmartPointer<vtkColorTransferFunction> m_TransferFunction;
- vtkSmartPointer<vtkPiecewiseFunction> m_OpacityTransferFunction;
int m_NumberOfLayers;
/** \brief Default constructor of the local storage. */
LocalStorage();
/** \brief Default destructor of the local storage. */
~LocalStorage() override;
};
/** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
mitk::LocalStorageHandler<LocalStorage> m_LSH;
/** \brief Get the LocalStorage corresponding to the current renderer. */
LocalStorage *GetLocalStorage(mitk::BaseRenderer *renderer);
/** \brief Set the default properties for general image rendering. */
static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
protected:
/** Default constructor */
MultiLabelSegmentationVtkMapper3D();
/** Default deconstructor */
~MultiLabelSegmentationVtkMapper3D() override;
/** \brief Does the actual resampling, without rendering the image yet.
* All the data is generated inside this method. The vtkProp (or Actor)
* is filled with content (i.e. the resliced image).
*
* After generation, a 4x4 transformation matrix(t) of the current slice is obtained
* from the vtkResliceImage object via GetReslicesAxis(). This matrix is
* applied to each textured plane (actor->SetUserTransform(t)) to transform everything
* to the actual 3D position (cf. the following image).
*
* \image html cameraPositioning3D.png
*
*/
void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
bool GenerateVolumeMapping(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs);
/** \brief Generates the look up table that should be used.
*/
void GenerateLookupTable(mitk::BaseRenderer* renderer);
};
} // namespace mitk
#endif
diff --git a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
index eea5b5e3c9..6e0e75742a 100644
--- a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
+++ b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
@@ -1,133 +1,134 @@
/*============================================================================
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 "mitkMultilabelObjectFactory.h"
#include "mitkBaseRenderer.h"
#include "mitkCoreObjectFactory.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include <mitkCoreServices.h>
#include <mitkIPropertyFilters.h>
#include <mitkLabelSetImageVtkMapper2D.h>
#include <mitkMultiLabelSegmentationVtkMapper3D.h>
#include <mitkPropertyFilter.h>
mitk::MultilabelObjectFactory::MultilabelObjectFactory() : CoreObjectFactoryBase()
{
static bool alreadyDone = false;
if (!alreadyDone)
{
MITK_DEBUG << "MultilabelObjectFactory c'tor" << std::endl;
CreateFileExtensionsMap();
alreadyDone = true;
}
}
mitk::MultilabelObjectFactory::~MultilabelObjectFactory()
{
}
mitk::Mapper::Pointer mitk::MultilabelObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper = nullptr;
mitk::BaseData *data = node->GetData();
if (id == mitk::BaseRenderer::Standard2D)
{
if ((dynamic_cast<mitk::LabelSetImage *>(data) != nullptr))
{
newMapper = mitk::LabelSetImageVtkMapper2D::New();
newMapper->SetDataNode(node);
}
}
else if (id == mitk::BaseRenderer::Standard3D)
{
if ((dynamic_cast<mitk::LabelSetImage*>(data) != nullptr))
{
newMapper = mitk::MultiLabelSegmentationVtkMapper3D::New();
newMapper->SetDataNode(node);
}
}
return newMapper;
}
void mitk::MultilabelObjectFactory::SetDefaultProperties(mitk::DataNode *node)
{
if (node == nullptr)
return;
if (node->GetData() == nullptr)
return;
if (dynamic_cast<LabelSetImage *>(node->GetData()) != nullptr)
{
mitk::LabelSetImageVtkMapper2D::SetDefaultProperties(node);
+ mitk::MultiLabelSegmentationVtkMapper3D::SetDefaultProperties(node);
auto propertyFilters = CoreServices::GetPropertyFilters();
if (propertyFilters != nullptr)
{
PropertyFilter labelSetImageFilter;
labelSetImageFilter.AddEntry("binaryimage.hoveringannotationcolor", PropertyFilter::Blacklist);
labelSetImageFilter.AddEntry("binaryimage.hoveringcolor", PropertyFilter::Blacklist);
labelSetImageFilter.AddEntry("binaryimage.selectedannotationcolor", PropertyFilter::Blacklist);
labelSetImageFilter.AddEntry("binaryimage.selectedcolor", PropertyFilter::Blacklist);
labelSetImageFilter.AddEntry("outline binary shadow color", PropertyFilter::Blacklist);
propertyFilters->AddFilter(labelSetImageFilter, "LabelSetImage");
}
}
}
std::string mitk::MultilabelObjectFactory::GetFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions({}, fileExtension);
return fileExtension.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetFileExtensionsMap()
{
return {};
}
mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetSaveFileExtensionsMap()
{
return {};
}
void mitk::MultilabelObjectFactory::CreateFileExtensionsMap()
{
}
std::string mitk::MultilabelObjectFactory::GetSaveFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions({}, fileExtension);
return fileExtension.c_str();
}
struct RegisterMultilabelObjectFactory
{
RegisterMultilabelObjectFactory() : m_Factory(mitk::MultilabelObjectFactory::New())
{
mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
}
~RegisterMultilabelObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
mitk::MultilabelObjectFactory::Pointer m_Factory;
};
static RegisterMultilabelObjectFactory registerMultilabelObjectFactory;