mitk::TestDICOMLoading::ImageList mitk::TestDICOMLoading::LoadFiles( const StringContainer& files )
{
for (StringContainer::const_iterator iter = files.begin();
iter != files.end();
++iter)
{
MITK_DEBUG << "File " << *iter;
}
ImageList result;
DicomSeriesReader::FileNamesGrouping seriesInFiles = DicomSeriesReader::GetSeries( files, true );
// TODO sort series UIDs, implementation of map iterator might differ on different platforms (or verify this is a standard topic??)
for (DicomSeriesReader::FileNamesGrouping::const_iterator seriesIter = seriesInFiles.begin();
seriesIter != seriesInFiles.end();
++seriesIter)
{
StringContainer files = seriesIter->second.GetFilenames();
DataNode::Pointer node = DicomSeriesReader::LoadDicomSeries( files );
if (node.IsNotNull())
{
Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
result.push_back( image );
}
else
{
}
}
return result;
}
DataNode *SegmentationSink::GetGroupNode()
{
DataNode::Pointer groupNode;
GetPointerParameter("Group node", groupNode);
return groupNode.GetPointer();
}
void mitk::BinaryThresholdULTool::CreateNewSegmentationFromThreshold(DataNode* node)
{
if (node)
{
Image::Pointer feedBackImage = dynamic_cast<Image*>( m_ThresholdFeedbackNode->GetData() );
if (feedBackImage.IsNotNull())
{
// create a new image of the same dimensions and smallest possible pixel type
DataNode::Pointer emptySegmentation = GetTargetSegmentationNode();
if (emptySegmentation)
{
// actually perform a thresholding and ask for an organ type
for (unsigned int timeStep = 0; timeStep < feedBackImage->GetTimeSteps(); ++timeStep)
{
try
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( feedBackImage );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer feedBackImage3D = timeSelector->GetOutput();
if (feedBackImage3D->GetDimension() == 2)
{
AccessFixedDimensionByItk_2( feedBackImage3D, ITKSetVolume, 2, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
}
else
{
AccessFixedDimensionByItk_2( feedBackImage3D, ITKSetVolume, 3, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
}
}
catch(...)
{
Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
}
}
//since we are maybe working on a smaller image, pad it to the size of the original image
if (m_OriginalImageNode.GetPointer() != m_NodeForThresholding.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, dynamic_cast<mitk::Image*> (emptySegmentation->GetData()));
padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
emptySegmentation->SetData(padFilter->GetOutput());
}
m_ToolManager->SetWorkingData( emptySegmentation );
m_ToolManager->GetWorkingData(0)->Modified();
}
}
}
}
void mitk::SceneReaderV1::GetLayerOrder(TiXmlDocument& document, const std::string& workingDirectory, std::vector<mitk::DataNode::Pointer> DataNodes, OrderedLayers& order)
{
typedef std::vector<mitk::DataNode::Pointer> DataNodeVector;
DataNodeVector::iterator nit = DataNodes.begin();
for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL || nit != DataNodes.end(); element = element->NextSiblingElement("node"), ++nit )
{
DataNode::Pointer node = *nit;
DecorateNodeWithProperties(node, element, workingDirectory);
int layer;
node->GetIntProperty("layer", layer);
std::string uid = element->Attribute("UID");
this->m_UnorderedLayers.insert( std::make_pair( layer, uid ) );
}
int lastLayer = itk::NumericTraits<int>::min();
UnorderedLayers::iterator it;
for (it = m_UnorderedLayers.begin(); it != m_UnorderedLayers.end(); it++)
{
int currentLayer = (*it).first;
if (currentLayer == lastLayer)
{
++currentLayer;
}
order.insert( std::make_pair( (*it).second, currentLayer ) );
lastLayer = currentLayer;
}
}
/*!
\brief PrepareMapperQueue iterates the datatree
PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers
wrt to their layer.
*/
void mitk::VtkPropRenderer::PrepareMapperQueue()
{
// variable for counting LOD-enabled mappers
m_NumberOfVisibleLODEnabledMappers = 0;
// Do we have to update the mappers ?
if (m_LastUpdateTime < GetMTime() || m_LastUpdateTime < this->GetCurrentWorldPlaneGeometry()->GetMTime())
{
Update();
}
else if (m_MapperID >= 1 && m_MapperID < 6)
Update();
// remove all text properties before mappers will add new ones
m_TextRenderer->RemoveAllViewProps();
for (unsigned int i = 0; i < m_TextCollection.size(); i++)
{
m_TextCollection[i]->Delete();
}
m_TextCollection.clear();
// clear priority_queue
m_MappersMap.clear();
int mapperNo = 0;
// DataStorage
if (m_DataStorage.IsNull())
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
const DataNode::Pointer node = it->Value();
if (node.IsNull())
continue;
const mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
if (mapper.IsNull())
continue;
bool visible = true;
node->GetVisibility(visible, this, "visible");
// The information about LOD-enabled mappers is required by RenderingManager
if (mapper->IsLODEnabled(this) && visible)
{
++m_NumberOfVisibleLODEnabledMappers;
}
// mapper without a layer property get layer number 1
int layer = 1;
node->GetIntProperty("layer", layer, this);
int nr = (layer << 16) + mapperNo;
m_MappersMap.insert(std::pair<int, Mapper *>(nr, mapper));
mapperNo++;
}
}
mitk::IFileWriter::ConfidenceLevel mitk::LegacyFileWriterService::GetConfidenceLevel() const
{
if (mitk::AbstractFileWriter::GetConfidenceLevel() == Unsupported)
return Unsupported;
DataNode::Pointer node = DataNode::New();
node->SetData(const_cast<BaseData *>(this->GetInput()));
return m_LegacyWriter->CanWriteDataType(node) ? Supported : Unsupported;
}
void mitk::BinaryThresholdULTool::CreateNewSegmentationFromThreshold(DataNode* node, const std::string& organName, const Color& color)
{
if (node)
{
Image::Pointer image = dynamic_cast<Image*>( m_NodeForThresholding->GetData() );
if (image.IsNotNull())
{
// create a new image of the same dimensions and smallest possible pixel type
DataNode::Pointer emptySegmentation = Tool::CreateEmptySegmentationNode( image, organName, color );
if (emptySegmentation)
{
// actually perform a thresholding and ask for an organ type
for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
{
try
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( image );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer image3D = timeSelector->GetOutput();
AccessFixedDimensionByItk_2( image3D, ITKThresholding, 3, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
}
catch(...)
{
Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
}
}
//since we are maybe working on a smaller image, pad it to the size of the original image
if (m_OriginalImageNode.GetPointer() != m_NodeForThresholding.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, dynamic_cast<mitk::Image*> (emptySegmentation->GetData()));
padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
emptySegmentation->SetData(padFilter->GetOutput());
}
if (DataStorage* ds = m_ToolManager->GetDataStorage())
{
ds->Add( emptySegmentation, m_OriginalImageNode );
}
m_ToolManager->SetWorkingData( emptySegmentation );
}
}
}
}
bool SegmentationSink::ReadyToRun()
{
Image::Pointer image;
GetPointerParameter("Input", image);
DataNode::Pointer groupNode;
GetPointerParameter("Group node", groupNode);
return image.IsNotNull() && groupNode.IsNotNull();
}
DataNode *SegmentationSink::LookForPointerTargetBelowGroupNode(const char *name)
{
DataNode::Pointer groupNode;
GetPointerParameter("Group node", groupNode);
if (groupNode.IsNotNull() && m_DataStorage.IsNotNull())
{
return m_DataStorage->GetNamedDerivedNode(name, groupNode, true);
}
return nullptr;
}
void mitk::ClippingPlaneInteractor3D::DeselectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
node->SetColor( 1.0, 1.0, 1.0 );
// Colorize surface / wireframe as inactive
this->ColorizeSurface(interactionEvent->GetSender(), -1.0);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
void mitk::ClippingPlaneInteractor3D::SelectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
node->SetColor(1.0, 0.0, 0.0);
// Colorize surface / wireframe dependend on distance from picked point
this->ColorizeSurface(interactionEvent->GetSender(), 0.0);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
void QmitkOdfMaximaExtractionView::ConvertPeaksFromMrtrix()
{
if (m_ImageNodes.empty())
return;
typedef itk::Image< float, 4 > ItkImageType;
typedef itk::MrtrixPeakImageConverter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
// cast to itk
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
mitk::Geometry3D::Pointer geom = mitkImg->GetGeometry();
typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
filter->SetInputImage(itkImg);
filter->GenerateData();
mitk::Vector3D outImageSpacing = geom->GetSpacing();
float maxSpacing = 1;
if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
maxSpacing = outImageSpacing[0];
else if (outImageSpacing[1] > outImageSpacing[2])
maxSpacing = outImageSpacing[1];
else
maxSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geom);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
void mitk::AffineBaseDataInteractor3D::SelectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
mitk::ColorProperty::Pointer selectedColor = dynamic_cast<mitk::ColorProperty*>(node->GetProperty(selectedColorPropertyName));
if ( selectedColor.IsNotNull() )
{
node->GetPropertyList()->SetProperty("color", selectedColor);
}
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
return;
}
mitk::StdFunctionCommand::ActionFunction mitk::DisplayActionEventFunctions::SetLevelWindowAction()
{
auto actionFunction = [](const itk::EventObject& displayInteractorEvent)
{
if (DisplaySetLevelWindowEvent().CheckEvent(&displayInteractorEvent))
{
const DisplaySetLevelWindowEvent* displayActionEvent = dynamic_cast<const DisplaySetLevelWindowEvent*>(&displayInteractorEvent);
const BaseRenderer::Pointer sendingRenderer = displayActionEvent->GetSender();
if (nullptr == sendingRenderer)
{
return;
}
// get the the topmost visible image of the sending renderer
DataStorage::Pointer storage = sendingRenderer->GetDataStorage();
DataStorage::SetOfObjects::ConstPointer allImageNodes = storage->GetSubset(NodePredicateDataType::New("Image"));
Point3D worldposition;
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(displayActionEvent->GetInteractionEvent());
sendingRenderer->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), worldposition);
auto globalCurrentTimePoint = sendingRenderer->GetTime();
DataNode::Pointer node = FindTopmostVisibleNode(allImageNodes, worldposition, globalCurrentTimePoint, sendingRenderer);
if (node.IsNull())
{
return;
}
LevelWindow levelWindow = LevelWindow();
node->GetLevelWindow(levelWindow);
ScalarType level = levelWindow.GetLevel();
ScalarType window = levelWindow.GetWindow();
level += displayActionEvent->GetLevel();
window += displayActionEvent->GetWindow();
levelWindow.SetLevelWindow(level, window);
auto* levelWindowProperty = dynamic_cast<LevelWindowProperty*>(node->GetProperty("levelwindow"));
if (nullptr != levelWindowProperty)
{
levelWindowProperty->SetLevelWindow(levelWindow);
sendingRenderer->GetRenderingManager()->RequestUpdateAll();
}
}
};
return actionFunction;
}
void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
return;
// Calculate time step of the input data for the specified renderer (integer value)
// this method is implemented in mitkMapper
this->CalculateTimeStep( renderer );
//check if updates occured in the node or on the display
FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
//set renderer independent shader properties
const DataNode::Pointer node = this->GetDataNode();
float thickness = 2.0;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
bool fiberfading = false;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
mitk::FiberBundle* fiberBundle = this->GetInput();
if (fiberBundle==nullptr)
return;
int lineWidth = 0;
node->GetIntProperty("LineWidth", lineWidth);
if (m_LineWidth!=lineWidth)
{
m_LineWidth = lineWidth;
fiberBundle->RequestUpdate2D();
}
if ( localStorage->m_LastUpdateTime<renderer->GetCurrentWorldPlaneGeometryUpdateTime() || localStorage->m_LastUpdateTime<fiberBundle->GetUpdateTime2D() )
{
this->UpdateShaderParameter(renderer);
this->GenerateDataForRenderer( renderer );
}
}
mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
{
DataNode::Pointer node;
if (dataElement)
{
const char* filename = dataElement->Attribute("file");
if ( filename )
{
try
{
std::vector<BaseData::Pointer> baseData = IOUtil::Load( workingDirectory + Poco::Path::separator() + filename );
if (baseData.size() > 1)
{
MITK_WARN << "Discarding multiple base data results from " << filename << " except the first one.";
}
node = DataNode::New();
node->SetData(baseData.front());
}
catch (std::exception& e)
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
error = true;
}
if (node.IsNull())
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
error = true;
}
}
}
// in case there was no <data> element we create a new empty node (for appending a propertylist later)
if (node.IsNull())
{
node = DataNode::New();
}
return node;
}
void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffsFromFsl(mitk::Image* mitkImg)
{
typedef itk::FslShCoefficientImageConverter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
typename FilterType::Pointer filter = FilterType::New();
filter->SetInputImage(caster->GetOutput());
filter->GenerateData();
typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
{
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkCi.GetPointer() );
img->SetVolume( itkCi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("FSL_ShCoefficientImage");
GetDataStorage()->Add(node);
}
{
mitk::QBallImage::Pointer img = mitk::QBallImage::New();
img->InitializeByItk( itkQbi.GetPointer() );
img->SetVolume( itkQbi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("FSL_QballImage");
GetDataStorage()->Add(node);
}
}
mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
{
DataNode::Pointer node;
if (dataElement)
{
const char* filename( dataElement->Attribute("file") );
if ( filename )
{
DataNodeFactory::Pointer factory = DataNodeFactory::New();
factory->SetFileName( workingDirectory + Poco::Path::separator() + filename );
try
{
factory->Update();
node = factory->GetOutput();
}
catch (std::exception& e)
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
error = true;
}
if (node.IsNull())
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
error = true;
}
}
}
// in case there was no <data> element we create a new empty node (for appending a propertylist later)
if (node.IsNull())
{
node = DataNode::New();
}
return node;
}
/*
* Checks if DataNodes associated with DataInteractors point back to them.
* If not remove the DataInteractors. (This can happen when s.o. tries to set DataNodes to multiple DataInteractors)
*/
void mitk::Dispatcher::RemoveOrphanedInteractors()
{
for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
{
DataNode::Pointer dn = (*it)->GetDataNode();
if (dn.IsNull())
{
it = m_Interactors.erase(it);
}
else
{
DataInteractor::Pointer interactor = dn->GetDataInteractor();
if (interactor != it->GetPointer())
{
it = m_Interactors.erase(it);
}
else
{
++it;
}
}
}
}
void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow* /*renWin*/)
{
if( m_DataStorage.IsNull() )
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
{
DataNode::Pointer node = *iter;
if ( node.IsNull() )
continue;
Mapper * mapper = node->GetMapper(m_MapperID);
if (mapper)
{
VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
if(vtkmapper)
vtkmapper->ReleaseGraphicsResources(this);
}
}
}
void mitk::FiberBundleXMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
{
//get information about current position of views
mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
//generate according cutting planes based on the view position
float sliceN[3], planeOrigin[3];
// since shader uses camera coordinates, transform origin and normal from worldcoordinates to cameracoordinates
planeOrigin[0] = (float) planeGeo->GetOrigin()[0];
planeOrigin[1] = (float) planeGeo->GetOrigin()[1];
planeOrigin[2] = (float) planeGeo->GetOrigin()[2];
sliceN[0] = planeGeo->GetNormal()[0];
sliceN[1] = planeGeo->GetNormal()[1];
sliceN[2] = planeGeo->GetNormal()[2];
float tmp1 = planeOrigin[0] * sliceN[0];
float tmp2 = planeOrigin[1] * sliceN[1];
float tmp3 = planeOrigin[2] * sliceN[2];
float d1 = tmp1 + tmp2 + tmp3; //attention, correct normalvector
float plane1[4];
plane1[0] = sliceN[0];
plane1[1] = sliceN[1];
plane1[2] = sliceN[2];
plane1[3] = d1;
float thickness = 2.0;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
bool fiberfading = false;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
// set Opacity
float fiberOpacity;
this->GetDataNode()->GetOpacity(fiberOpacity, NULL);
DataNode::Pointer node = this->GetDataNode();
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",plane1[3],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",plane1[0],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",plane1[1],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",plane1[2],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberThickness",thickness,renderer);
node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading,renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity,renderer);
}
void mitk::SegmentationsProcessingTool::ProcessAllObjects()
{
m_FailedNodes.clear();
StartProcessingAllData();
ToolManager::DataVectorType nodes = m_ToolManager->GetWorkingData();
ProgressBar::GetInstance()->AddStepsToDo(nodes.size() + 2);
// for all selected nodes
for ( ToolManager::DataVectorType::iterator nodeiter = nodes.begin();
nodeiter != nodes.end();
++nodeiter )
{
DataNode::Pointer node = *nodeiter;
if ( !ProcessOneWorkingData(node) )
{
std::string nodeName;
m_FailedNodes += " '";
if ( node->GetName( nodeName ) )
{
m_FailedNodes += nodeName.c_str();
}
else
{
m_FailedNodes += "(no name)";
}
m_FailedNodes += "'";
}
ProgressBar::GetInstance()->Progress();
}
FinishProcessingAllData();
ProgressBar::GetInstance()->Progress(2);
}
void QmitkCreatePolygonModelAction::Run(const QList<DataNode::Pointer> &selectedNodes)
{
DataNode::Pointer selectedNode = selectedNodes[0];
Image::Pointer image = dynamic_cast<mitk::Image *>(selectedNode->GetData());
if (image.IsNull())
return;
try
{
if (!m_IsSmoothed)
{
ShowSegmentationAsSurface::Pointer surfaceFilter = ShowSegmentationAsSurface::New();
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ProcessingError(), errorCommand);
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
surfaceFilter->SetParameter("Show result", true);
surfaceFilter->SetParameter("Sync visibility", false);
surfaceFilter->SetParameter("Smooth", false);
surfaceFilter->SetParameter("Apply median", false);
surfaceFilter->SetParameter("Median kernel size", 3u);
surfaceFilter->SetParameter("Gaussian SD", 1.5f);
surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated);
surfaceFilter->SetParameter("Decimation rate", 0.8f);
StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
surfaceFilter->StartAlgorithm();
}
else
{
ShowSegmentationAsSmoothedSurface::Pointer surfaceFilter = ShowSegmentationAsSmoothedSurface::New();
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
berry::IWorkbenchPart::Pointer activePart =
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->GetActivePart();
mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(activePart.GetPointer());
mitk::SliceNavigationController* timeNavController = 0;
if (renderPart != 0)
{
timeNavController = renderPart->GetRenderingManager()->GetTimeNavigationController();
}
int timeNr = timeNavController != 0 ? timeNavController->GetTime()->GetPos() : 0;
surfaceFilter->SetParameter("TimeNr", timeNr);
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
bool smoothingHint = segPref->GetBool("smoothing hint", true);
float smoothing = (float)segPref->GetDouble("smoothing value", 1.0);
float decimation = (float)segPref->GetDouble("decimation rate", 0.5);
float closing = (float)segPref->GetDouble("closing ratio", 0.0);
if (smoothingHint)
{
smoothing = 0.0;
Vector3D spacing = image->GetGeometry()->GetSpacing();
for (Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter)
smoothing = max(smoothing, *iter);
}
surfaceFilter->SetParameter("Smoothing", smoothing);
surfaceFilter->SetParameter("Decimation", decimation);
surfaceFilter->SetParameter("Closing", closing);
ProgressBar::GetInstance()->AddStepsToDo(8);
StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background...");
try {
surfaceFilter->StartAlgorithm();
} catch (...)
{
MITK_ERROR<<"Error creating smoothed polygon model: Not enough memory!";
}
}
}
catch(...)
{
MITK_ERROR << "Surface creation failed!";
}
}
void mitk::PlanarFigureInteractor::AddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
{
const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
if ( positionEvent == nullptr )
return;
const DataNode::Pointer node = this->GetDataNode();
const BaseData::Pointer data = node->GetData();
/*
* Added check for "initiallyplaced" due to bug 13097:
*
* There are two possible cases in which a point can be inserted into a PlanarPolygon:
*
* 1. The figure is currently drawn -> the point will be appended at the end of the figure
* 2. A point is inserted at a userdefined position after the initial placement of the figure is finished
*
* In the second case we need to determine the proper insertion index. In the first case the index always has
* to be -1 so that the point is appended to the end.
*
* These changes are necessary because of a mac os x specific issue: If a users draws a PlanarPolygon then the
* next point to be added moves according to the mouse position. If then the user left clicks in order to add
* a point one would assume the last move position is identical to the left click position. This is actually the
* case for windows and linux but somehow NOT for mac. Because of the insertion logic of a new point in the
* PlanarFigure then for mac the wrong current selected point is determined.
*
* With this check here this problem can be avoided. However a redesign of the insertion logic should be considered
*/
bool isFigureFinished = false;
data->GetPropertyList()->GetBoolProperty("initiallyplaced", isFigureFinished);
bool selected = false;
bool isEditable = true;
node->GetBoolProperty("selected", selected);
node->GetBoolProperty("planarfigure.iseditable", isEditable);
if ( !selected || !isEditable )
{
return;
}
mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(data.GetPointer());
// We can't derive a new control point from a polyline of a Bezier curve
// as all control points contribute to each polyline point.
if (dynamic_cast<PlanarBezierCurve*>(planarFigure) != nullptr && isFigureFinished)
return;
const mitk::PlaneGeometry *planarFigureGeometry = planarFigure->GetPlaneGeometry();
const mitk::AbstractTransformGeometry *abstractTransformGeometry =
dynamic_cast< AbstractTransformGeometry * >( planarFigure->GetGeometry( 0 ) );
if ( abstractTransformGeometry != nullptr)
return;
// If the planarFigure already has reached the maximum number
if ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() )
{
return;
}
// Extract point in 2D world coordinates (relative to PlaneGeometry of
// PlanarFigure)
Point2D point2D, projectedPoint;
if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
{
return;
}
// TODO: check segment of polyline we clicked in
int nextIndex = -1;
// We only need to check which position to insert the control point
// when interacting with a PlanarPolygon. For all other types
// new control points will always be appended
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
if (dynamic_cast<mitk::PlanarPolygon*>(planarFigure) && isFigureFinished)
{
nextIndex = this->IsPositionOverFigure(
positionEvent,
planarFigure,
planarFigureGeometry,
projectionPlane,
projectedPoint
);
}
// Add point as new control point
if ( planarFigure->IsPreviewControlPointVisible() )
{
point2D = planarFigure->GetPreviewControlPoint();
}
planarFigure->AddControlPoint( point2D, planarFigure->GetControlPointForPolylinePoint( nextIndex, 0 ) );
if ( planarFigure->IsPreviewControlPointVisible() )
{
planarFigure->SelectControlPoint( nextIndex );
planarFigure->ResetPreviewContolPoint();
}
// Re-evaluate features
planarFigure->EvaluateFeatures();
//this->LogPrintPlanarFigureQuantities( planarFigure );
// Update rendered scene
renderer->GetRenderingManager()->RequestUpdateAll();
}
void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
{
DataNode::Pointer node = DataNode::New();
bool wireframe = false;
GetParameter("Wireframe", wireframe);
if (wireframe)
{
VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
node->GetProperty("material.representation"));
if (representation != nullptr)
representation->SetRepresentationToWireframe();
}
node->SetProperty("opacity", FloatProperty::New(1.0));
node->SetProperty("line width", IntProperty::New(1));
node->SetProperty("scalar visibility", BoolProperty::New(false));
std::string groupNodeName = "surface";
DataNode *groupNode = GetGroupNode();
if (groupNode != nullptr)
groupNode->GetName(groupNodeName);
node->SetProperty("name", StringProperty::New(groupNodeName));
node->SetData(m_Surface);
BaseProperty *colorProperty = groupNode->GetProperty("color");
if (colorProperty != nullptr)
node->ReplaceProperty("color", colorProperty->Clone());
else
node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
bool showResult = true;
GetParameter("Show result", showResult);
bool syncVisibility = false;
GetParameter("Sync visibility", syncVisibility);
Image::Pointer image;
GetPointerParameter("Input", image);
BaseProperty *organTypeProperty = image->GetProperty("organ type");
if (organTypeProperty != nullptr)
m_Surface->SetProperty("organ type", organTypeProperty);
BaseProperty *visibleProperty = groupNode->GetProperty("visible");
if (visibleProperty != nullptr && syncVisibility)
node->ReplaceProperty("visible", visibleProperty->Clone());
else
node->SetProperty("visible", BoolProperty::New(showResult));
InsertBelowGroupNode(node);
Superclass::ThreadedUpdateSuccessful();
}
void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
{
DataNode::Pointer node = LookForPointerTargetBelowGroupNode("Surface representation");
bool addToTree = node.IsNull();
if (addToTree)
{
node = DataNode::New();
bool wireframe = false;
GetParameter("Wireframe", wireframe);
if (wireframe)
{
VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
node->GetProperty("material.representation"));
if (representation != NULL)
representation->SetRepresentationToWireframe();
}
node->SetProperty("opacity", FloatProperty::New(1.0));
node->SetProperty("line width", IntProperty::New(1));
node->SetProperty("scalar visibility", BoolProperty::New(false));
UIDGenerator uidGenerator("Surface_");
node->SetProperty("FILENAME", StringProperty::New(uidGenerator.GetUID() + ".vtk"));
std::string groupNodeName = "surface";
DataNode *groupNode = GetGroupNode();
if (groupNode != NULL)
groupNode->GetName(groupNodeName);
node->SetProperty("name", StringProperty::New(groupNodeName));
}
node->SetData(m_Surface);
if (addToTree)
{
DataNode* groupNode = GetGroupNode();
if (groupNode != NULL)
{
groupNode->SetProperty("Surface representation", SmartPointerProperty::New(node));
BaseProperty *colorProperty = groupNode->GetProperty("color");
if (colorProperty != NULL)
node->ReplaceProperty("color", colorProperty);
else
node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
bool showResult = true;
GetParameter("Show result", showResult);
bool syncVisibility = false;
GetParameter("Sync visibility", syncVisibility);
Image::Pointer image;
GetPointerParameter("Input", image);
BaseProperty *organTypeProperty = image->GetProperty("organ type");
if (organTypeProperty != NULL)
m_Surface->SetProperty("organ type", organTypeProperty);
BaseProperty *visibleProperty = groupNode->GetProperty("visible");
if (visibleProperty != NULL && syncVisibility)
node->ReplaceProperty("visible", visibleProperty);
else
node->SetProperty("visible", BoolProperty::New(showResult));
}
InsertBelowGroupNode(node);
}
Superclass::ThreadedUpdateSuccessful();
}
void QmitkCreatePolygonModelAction::Run(const QList<DataNode::Pointer> &selectedNodes)
{
DataNode::Pointer selectedNode = selectedNodes[0];
Image::Pointer image = dynamic_cast<mitk::Image *>(selectedNode->GetData());
if (image.IsNull())
{
return;
}
try
{
// Get preference properties for smoothing and decimation
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
bool smoothingHint = segPref->GetBool("smoothing hint", true);
ScalarType smoothing = segPref->GetDouble("smoothing value", 1.0);
ScalarType decimation = segPref->GetDouble("decimation rate", 0.5);
if (smoothingHint)
{
smoothing = 0.0;
Vector3D spacing = image->GetGeometry()->GetSpacing();
for (Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter)
smoothing = max(smoothing, *iter);
}
ShowSegmentationAsSurface::Pointer surfaceFilter = ShowSegmentationAsSurface::New();
// Activate callback functions
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ProcessingError(), errorCommand);
// set filter parameter
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
surfaceFilter->SetParameter("Show result", true);
surfaceFilter->SetParameter("Sync visibility", false);
surfaceFilter->SetParameter("Median kernel size", 3u);
surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated);
surfaceFilter->SetParameter("Decimation rate", (float) decimation);
if (m_IsSmoothed)
{
surfaceFilter->SetParameter("Apply median", true);
surfaceFilter->SetParameter("Smooth", true);
surfaceFilter->SetParameter("Gaussian SD", sqrtf(smoothing)); // use sqrt to account for setting of variance in preferences
StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background...");
}
else
{
surfaceFilter->SetParameter("Apply median", false);
surfaceFilter->SetParameter("Smooth", false);
StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
}
surfaceFilter->StartAlgorithm();
}
catch(...)
{
MITK_ERROR << "Surface creation failed!";
}
}
int mitk::SegTool2D::AddContourmarker()
{
if (m_LastEventSender == NULL)
return -1;
us::ServiceReference<PlanePositionManagerService> serviceRef =
us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
PlanePositionManagerService* service = us::GetModuleContext()->GetService(serviceRef);
unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
// the first geometry is needed otherwise restoring the position is not working
const mitk::PlaneGeometry* plane = dynamic_cast<const PlaneGeometry*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())->GetPlaneGeometry(0));
unsigned int size = service->GetNumberOfPlanePositions();
unsigned int id = service->AddNewPlanePosition(plane, slicePosition);
mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
mitk::Point2D p1;
plane->Map(plane->GetCenter(), p1);
mitk::Point2D p2 = p1;
p2[0] -= plane->GetSpacing()[0];
p2[1] -= plane->GetSpacing()[1];
contourMarker->PlaceFigure( p1 );
contourMarker->SetCurrentControlPoint( p1 );
contourMarker->SetPlaneGeometry( const_cast<PlaneGeometry*>(plane));
std::stringstream markerStream;
mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
markerStream << m_Contourmarkername ;
markerStream << " ";
markerStream << id+1;
DataNode::Pointer rotatedContourNode = DataNode::New();
rotatedContourNode->SetData(contourMarker);
rotatedContourNode->SetProperty( "name", StringProperty::New(markerStream.str()) );
rotatedContourNode->SetProperty( "isContourMarker", BoolProperty::New(true));
rotatedContourNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, m_LastEventSender );
rotatedContourNode->SetProperty( "includeInBoundingBox", BoolProperty::New(false));
rotatedContourNode->SetProperty( "helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
rotatedContourNode->SetProperty( "planarfigure.drawcontrolpoints", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawname", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawoutline", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawshadow", BoolProperty::New(false));
if (plane)
{
if ( id == size )
{
m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
else
{
mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
iter != markers->end();
++iter)
{
std::string nodeName = (*iter)->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
if(id == markerId)
{
return id;
}
}
m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
}
return id;
}
bool mitk::SceneReaderV1::LoadScene( TiXmlDocument& document, const std::string& workingDirectory, DataStorage* storage )
{
assert(storage);
bool error(false);
// TODO prepare to detect errors (such as cycles) from wrongly written or edited xml files
// iterate all nodes
// first level nodes should be <node> elements
for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL; element = element->NextSiblingElement("node") )
{
// 1. if there is a <data type="..." file="..."> element,
// - construct a name for the appropriate serializer
// - try to instantiate this serializer via itk object factory
// - if serializer could be created, use it to read the file into a BaseData object
// - if successful, call the new node's SetData(..)
DataNode::Pointer node = LoadBaseDataFromDataTag( element->FirstChildElement("data"), workingDirectory, error );
// 2. check child nodes
const char* uida = element->Attribute("UID");
std::string uid("");
if (uida)
{
uid = uida;
m_NodeForID[uid] = node.GetPointer();
m_IDForNode[ node.GetPointer() ] = uid;
}
else
{
MITK_ERROR << "No UID found for current node. Node will have no parents.";
error = true;
}
// remember node for later adding to DataStorage
m_Nodes.insert( std::make_pair( node, std::list<std::string>() ) );
// 3. if there are <source> elements, remember parent objects
for( TiXmlElement* source = element->FirstChildElement("source"); source != NULL; source = source->NextSiblingElement("source") )
{
const char* sourceUID = source->Attribute("UID");
if (sourceUID)
{
m_Nodes[node].push_back( std::string(sourceUID) );
}
}
// 5. if there are <properties> nodes,
// - instantiate the appropriate PropertyListDeSerializer
// - use them to construct PropertyList objects
// - add these properties to the node (if necessary, use renderwindow name)
bool success = DecorateNodeWithProperties(node, element, workingDirectory);
if (!success)
{
MITK_ERROR << "Could not load properties for node.";
error = true;
}
} // end for all <node>
// remove all unknown parent UIDs
for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
nodesIter != m_Nodes.end();
++nodesIter)
{
for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
parentsIter != nodesIter->second.end();)
{
if (m_NodeForID.find( *parentsIter ) == m_NodeForID.end())
{
parentsIter = nodesIter->second.erase( parentsIter );
MITK_WARN << "Found a DataNode with unknown parents. Will add it to DataStorage without any parent objects.";
error = true;
}
else
{
++parentsIter;
}
}
}
// repeat
// for all created nodes
unsigned int lastMapSize(0);
while ( lastMapSize != m_Nodes.size()) // this is to prevent infinite loops; each iteration must at least add one node to DataStorage
{
lastMapSize = m_Nodes.size();
for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
nodesIter != m_Nodes.end();
++nodesIter)
{
bool addNow(true);
// if any parent node is not yet in DataStorage, skip node for now and check later
for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
parentsIter != nodesIter->second.end();
++parentsIter)
{
if ( !storage->Exists( m_NodeForID[ *parentsIter ] ) )
{
addNow = false;
break;
}
}
if (addNow)
{
DataStorage::SetOfObjects::Pointer parents = DataStorage::SetOfObjects::New();
for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
parentsIter != nodesIter->second.end();
++parentsIter)
{
parents->push_back( m_NodeForID[ *parentsIter ] );
}
// if all parents are found in datastorage (or are unknown), add node to DataStorage
storage->Add( nodesIter->first, parents );
// remove this node from m_Nodes
m_Nodes.erase( nodesIter );
// break this for loop because iterators are probably invalid
break;
}
}
}
// All nodes that are still in m_Nodes at this point are not part of a proper directed graph structure. We'll add such nodes without any parent information.
for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
nodesIter != m_Nodes.end();
++nodesIter)
{
storage->Add( nodesIter->first );
MITK_WARN << "Encountered node that is not part of a directed graph structure. Will be added to DataStorage without parents.";
error = true;
}
return !error;
}
mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
const std::string &organName,
const mitk::Color &color)
{
if (!image)
return nullptr;
// decorate the datatreenode with some properties
DataNode::Pointer segmentationNode = DataNode::New();
segmentationNode->SetData(image);
// name
segmentationNode->SetProperty("name", StringProperty::New(organName));
// visualization properties
segmentationNode->SetProperty("binary", BoolProperty::New(true));
segmentationNode->SetProperty("color", ColorProperty::New(color));
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
lut->SetType(mitk::LookupTable::MULTILABEL);
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
lutProp->SetLookupTable(lut);
segmentationNode->SetProperty("LookupTable", lutProp);
segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
segmentationNode->SetProperty("layer", IntProperty::New(10));
segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
segmentationNode->SetProperty("reslice interpolation",
VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
// slices sometimes (only visual effect, not
// different data)
// For MITK-3M3 release, the volume of all segmentations should be shown
segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
return segmentationNode;
}