mitk::Surface::Pointer mitk::PlanarFigureSegmentationController::CreateSurfaceFromPlanarFigure( mitk::PlanarFigure::Pointer figure )
{
if ( figure.IsNull() )
{
MITK_ERROR << "Given PlanarFigure is NULL. Please provide valid PlanarFigure.";
return NULL;
}
mitk::Surface::Pointer newSurface = mitk::Surface::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
const mitk::Geometry2D* figureGeometry = figure->GetGeometry2D();
// Get the polyline
mitk::PlanarFigure::PolyLineType planarPolyLine = figure->GetPolyLine(0);
mitk::PlanarFigure::PolyLineType::iterator iter;
// iterate over the polyline, ...
int pointCounter = 0;
for( iter = planarPolyLine.begin(); iter != planarPolyLine.end(); iter++ )
{
// ... determine the world-coordinates
mitk::Point2D polyLinePoint = iter->Point;
mitk::Point3D pointInWorldCoordiantes;
figureGeometry->Map( polyLinePoint, pointInWorldCoordiantes );
// and add them as new points to the vtkPoints
points->InsertNextPoint( pointInWorldCoordiantes[0], pointInWorldCoordiantes[1], pointInWorldCoordiantes[2] );
++pointCounter;
}
// create a polygon with the points of the polyline
polygon->GetPointIds()->SetNumberOfIds( pointCounter );
for(int i = 0; i < pointCounter; i++)
{
polygon->GetPointIds()->SetId(i,i);
}
// initialize the vtkCellArray and vtkPolyData
cells->InsertNextCell(polygon);
polyData->SetPoints(points);
polyData->SetPolys( cells );
// set the polydata to the surface
newSurface->SetVtkPolyData( polyData );
return newSurface;
}
void QmitkImageStatisticsCalculationThread::Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig )
{
// reset old values
if( this->m_StatisticsImage.IsNotNull() )
this->m_StatisticsImage = 0;
if( this->m_BinaryMask.IsNotNull() )
this->m_BinaryMask = 0;
if( this->m_PlanarFigureMask.IsNotNull())
this->m_PlanarFigureMask = 0;
// set new values if passed in
if(image.IsNotNull())
this->m_StatisticsImage = image->Clone();
if(binaryImage.IsNotNull())
this->m_BinaryMask = binaryImage->Clone();
if(planarFig.IsNotNull())
this->m_PlanarFigureMask = planarFig->Clone();
}
void QmitkImageStatisticsCalculationThread::Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig )
{
// reset old values
if( this->m_StatisticsImage.IsNotNull() )
this->m_StatisticsImage = 0;
if( this->m_BinaryMask.IsNotNull() )
this->m_BinaryMask = 0;
if( this->m_PlanarFigureMask.IsNotNull())
this->m_PlanarFigureMask = 0;
// set new values if passed in
if(image.IsNotNull())
this->m_StatisticsImage = image->Clone();
if(binaryImage.IsNotNull())
this->m_BinaryMask = binaryImage->Clone();
if(planarFig.IsNotNull())
this->m_PlanarFigureMask = dynamic_cast<mitk::PlanarFigure*>(planarFig.GetPointer()); // once clone methods for planar figures are implemented, copy the data here!
}
void RunTest(mitk::PlanarFigure::Pointer figure, std::string interactionXmlPath, std::string referenceFigurePath)
{
mitk::DataNode::Pointer node;
mitk::PlanarFigureInteractor::Pointer figureInteractor;
//Create DataNode as a container for our PlanarFigure
node = mitk::DataNode::New();
node->SetData(figure);
mitk::InteractionTestHelper interactionTestHelper(GetTestDataFilePath(interactionXmlPath));
//Load a bounding image
mitk::Image::Pointer testImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("Pic3D.nrrd"));
figure->SetGeometry(testImage->GetGeometry());
mitk::DataNode::Pointer dn = mitk::DataNode::New();
dn->SetData(testImage);
interactionTestHelper.AddNodeToStorage(dn);
interactionTestHelper.GetDataStorage()->Add(node, dn);
node->SetName("PLANAR FIGURE");
// set as selected
node->SetSelected(true);
node->AddProperty("selected", mitk::BoolProperty::New(true));
//Load state machine
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule("MitkPlanarFigure");
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( node );
//Start Interaction
interactionTestHelper.PlaybackInteraction();
//Load reference PlanarFigure
mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New();
reader->SetFileName(GetTestDataFilePath(referenceFigurePath));
reader->Update();
mitk::PlanarFigure::Pointer reference = reader->GetOutput(0);
//Compare figures
MITK_ASSERT_EQUAL(figure, reference, "Compare figure with reference");
}
void mitk::PlanarFigureSegmentationController::AddPlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
{
if ( planarFigure.IsNull() )
return;
bool newFigure = true;
std::size_t indexOfFigure = 0;
for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
{
if( m_PlanarFigureList.at(i) == planarFigure )
{
indexOfFigure = i;
newFigure = false;
break;
}
}
mitk::Surface::Pointer figureAsSurface = NULL;
if ( newFigure )
{
m_PlanarFigureList.push_back( planarFigure );
figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
m_SurfaceList.push_back( figureAsSurface );
if (!m_PlanarFigureList.empty())
{
indexOfFigure = m_PlanarFigureList.size() -1 ;
}
}
else
{
figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
m_SurfaceList.at(indexOfFigure) = figureAsSurface;
}
if ( m_ReduceFilter.IsNull() )
{
InitializeFilters();
}
m_ReduceFilter->SetInput( indexOfFigure, figureAsSurface );
m_NormalsFilter->SetInput( indexOfFigure, m_ReduceFilter->GetOutput( indexOfFigure ) );
m_DistanceImageCreator->SetInput( indexOfFigure, m_NormalsFilter->GetOutput( indexOfFigure ) );
}
void mitk::PlanarFigureSegmentationController::RemovePlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
{
if ( planarFigure.IsNull() )
return;
bool figureFound = false;
std::size_t indexOfFigure = 0;
for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
{
if( m_PlanarFigureList.at(i) == planarFigure )
{
indexOfFigure = i;
figureFound = true;
break;
}
}
if ( !figureFound )
return;
// TODO: fix this! The following code had to be removed as the method
// RemoveInputs() has been removed in ITK 4
// The remaining code works correctly but is slower
if ( false && indexOfFigure == m_PlanarFigureList.size()-1 )
{
// Ff the removed figure was the last one in the list, we can simply
// remove the last input from each filter.
// m_DistanceImageCreator->RemoveInputs( m_NormalsFilter->GetOutput( indexOfFigure ) );
// m_NormalsFilter->RemoveInput( m_ReduceFilter->GetOutput( indexOfFigure ) );
// m_ReduceFilter->RemoveInput( const_cast<mitk::Surface*>(m_ReduceFilter->GetInput(indexOfFigure)) );
}
else
{
// this is not very nice! If the figure that has been removed is NOT the last
// one in the list we have to create new filters and add all remaining
// inputs again.
//
// Has to be done as the filters do not work when removing an input
// other than the last one.
// create new filters
InitializeFilters();
// and add all existing surfaces
SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
for ( surfaceIter = m_SurfaceList.begin(); surfaceIter!=m_SurfaceList.end(); surfaceIter++ )
{
m_ReduceFilter->SetInput( indexOfFigure, (*surfaceIter) );
m_NormalsFilter->SetInput( indexOfFigure, m_ReduceFilter->GetOutput( indexOfFigure ) );
m_DistanceImageCreator->SetInput( indexOfFigure, m_NormalsFilter->GetOutput( indexOfFigure ) );
}
}
PlanarFigureListType::iterator whereIter = m_PlanarFigureList.begin();
whereIter += indexOfFigure;
m_PlanarFigureList.erase( whereIter );
SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
surfaceIter += indexOfFigure;
m_SurfaceList.erase( surfaceIter );
}
static mitk::PlanarFigure::Pointer Clone(mitk::PlanarFigure::Pointer original)
{
return original->Clone();
}
void GetImageStatisticsNoRules() {
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
//no rules + 1 image --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer emptyStatistic;
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
//no rules + 1 image + 1 mask --> test return nullptr
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
//no rules + 1 image + 1 planarFigure --> test return nullptr
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
}
void GetImageStatisticsInvalid()
{
CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
CPPUNIT_ASSERT_THROW(mitk::ImageStatisticsContainerManager::GetImageStatistics(nullptr, m_image.GetPointer()), mitk::Exception);
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
CPPUNIT_ASSERT_THROW(mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), nullptr), mitk::Exception);
CPPUNIT_ASSERT_THROW(mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), nullptr, m_mask.GetPointer()), mitk::Exception);
CPPUNIT_ASSERT_THROW(mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), nullptr, m_planarFigure.GetPointer()), mitk::Exception);
}
void GetImageStatisticsWithImageAndMaskNotConnected()
{
//create rules connection + add statistics to dataStorage
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
CreateNodeRelationMask(m_statisticsContainer.GetPointer(), m_mask.GetPointer());
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
//rule: (image-->statistics, mask-->statistics), 1 connected image --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer statisticsWithImage;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected mask --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndMaskNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageNotConnectedAndMaskNotConnected = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image2.GetPointer(), m_mask2.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageNotConnectedAndMaskNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 connected mask --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer statisticsWithImageAndMaskNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskNotConnected = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image2.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected planarFigure --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected planarFigure --> test return nullptr
mitk::ImageStatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndPlanarFigureNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = mitk::ImageStatisticsContainerManager::GetImageStatistics(standaloneDataStorage.GetPointer(), m_image2.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
}
