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::SegmentationInterpolationController::SetSegmentationVolume( const Image* segmentation )
{
// clear old information (remove all time steps
m_SegmentationCountInSlice.clear();
// delete this from the list of interpolators
InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( segmentation );
if ( iter != s_InterpolatorForImage.end() )
{
s_InterpolatorForImage.erase( iter );
}
if (!segmentation) return;
if (segmentation->GetDimension() > 4 || segmentation->GetDimension() < 3)
{
itkExceptionMacro("SegmentationInterpolationController needs a 3D-segmentation or 3D+t, not 2D.");
}
if (m_Segmentation != segmentation)
{
// observe Modified() event of image
itk::ReceptorMemberCommand<SegmentationInterpolationController>::Pointer command = itk::ReceptorMemberCommand<SegmentationInterpolationController>::New();
command->SetCallbackFunction( this, &SegmentationInterpolationController::OnImageModified );
segmentation->AddObserver( itk::ModifiedEvent(), command );
}
m_Segmentation = segmentation;
m_SegmentationCountInSlice.resize( m_Segmentation->GetTimeSteps() );
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
m_SegmentationCountInSlice[timeStep].resize(3);
for (unsigned int dim = 0; dim < 3; ++dim)
{
m_SegmentationCountInSlice[timeStep][dim].clear();
m_SegmentationCountInSlice[timeStep][dim].resize( m_Segmentation->GetDimension(dim) );
m_SegmentationCountInSlice[timeStep][dim].assign( m_Segmentation->GetDimension(dim), 0 );
}
}
s_InterpolatorForImage.insert( std::make_pair( m_Segmentation, this ) );
// for all timesteps
// scan whole image
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer segmentation3D = timeSelector->GetOutput();
AccessFixedDimensionByItk_2( segmentation3D, ScanWholeVolume, 3, m_Segmentation, timeStep );
}
//PrintStatus();
SetReferenceVolume( m_ReferenceImage );
Modified();
}
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 );
}
}
}
}
void mitk::RegionGrowingTool::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
{
mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
if (!positionEvent) return;
MITK_DEBUG << "OnMousePressed";
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_LastScreenPosition = positionEvent->GetPointerPositionOnScreen();
// ReferenceSlice is from the underlying image, WorkingSlice from the active segmentation (can be empty)
m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice( positionEvent );
m_WorkingSlice = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
if (m_WorkingSlice.IsNotNull()) // can't do anything without a working slice (i.e. a possibly empty segmentation)
{
MITK_DEBUG << "OnMousePressed: got working slice";
// 2. Determine if the user clicked inside or outside of the segmentation/working slice (i.e. the whole volume)
mitk::BaseGeometry::Pointer workingSliceGeometry;
workingSliceGeometry = m_WorkingSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
workingSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), m_SeedPoint);
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
if (workingSliceGeometry->IsIndexInside(m_SeedPoint))
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates " << m_SeedPoint << ") is inside working slice";
// 3. determine the pixel value under the last click to determine what to do
bool inside(true);
AccessFixedDimensionByItk_2(m_WorkingSlice, IsInsideSegmentation, 2, indexInWorkingSlice2D, &inside);
m_PaintingPixelValue = inside ? 0 : 1;
if (inside)
{
MITK_DEBUG << "Clicked inside segmentation";
// For now, we're doing nothing when the user clicks inside the segmentation. Behaviour can be implemented via OnMousePressedInside()
// When you do, be sure to remove the m_PaintingPixelValue check in OnMouseMoved() and OnMouseReleased()
return;
}
else
{
MITK_DEBUG << "Clicked outside of segmentation";
OnMousePressedOutside(nullptr, interactionEvent);
}
}
}
}
void mitk::ExtractSliceFilter2::GenerateData()
{
if (nullptr != m_Impl->InterpolateImageFunction && this->GetInput()->GetMTime() < this->GetMTime())
return;
const auto* inputImage = this->GetInput();
AccessFixedDimensionByItk_2(inputImage, CreateInterpolateImageFunction, 3, this->GetInterpolator(), m_Impl->InterpolateImageFunction);
this->AllocateOutputs();
auto outputRegion = this->GetOutput()->GetLargestPossibleRegion();
AccessFixedDimensionByItk_3(inputImage, ::GenerateData, 3, this->GetOutput(), outputRegion, m_Impl->InterpolateImageFunction);
}
void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, unsigned int timeStep, Image* sliceImage, int paintingPixelValue )
{
// 1. Use ipSegmentation to draw a filled(!) contour into a new 8 bit 2D image, which will later be copied back to the slice.
// We don't work on the "real" working data, because ipSegmentation would restrict us to 8 bit images
// convert the projected contour into a ipSegmentation format
mitkIpInt4_t* picContour = new mitkIpInt4_t[2 * projectedContour->GetNumberOfVertices(timeStep)];
unsigned int index(0);
ContourModel::VertexIterator iter = projectedContour->Begin(timeStep);
ContourModel::VertexIterator end = projectedContour->End(timeStep);
while( iter != end)
{
picContour[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[0] + 1.0 ); // +0.5 wahrscheinlich richtiger
picContour[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[1] + 1.0 );
//MITK_INFO << "mitk 2d [" << (*iter)[0] << ", " << (*iter)[1] << "] pic [" << picContour[ 2*index+0] << ", " << picContour[ 2*index+1] << "]";
iter++;
index++;
}
assert( sliceImage->GetSliceData() );
mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
CastToIpPicDescriptor( sliceImage, originalPicSlice);
mitkIpPicDescriptor* picSlice = ipMITKSegmentationNew( originalPicSlice );
ipMITKSegmentationClear( picSlice );
assert( originalPicSlice && picSlice );
// here comes the actual contour filling algorithm (from ipSegmentation/Graphics Gems)
ipMITKSegmentationCombineRegion ( picSlice, picContour, projectedContour->GetNumberOfVertices(timeStep), NULL, IPSEGMENTATION_OR, 1); // set to 1
delete[] picContour;
// 2. Copy the filled contour to the working data slice
// copy all pixels that are non-zero to the original image (not caring for the actual type of the working image). perhaps make the replace value a parameter ( -> general painting tool ).
// make the pic slice an mitk/itk image (as little ipPic code as possible), call a templated method with accessbyitk, iterate over the original and the modified slice
Image::Pointer ipsegmentationModifiedSlice = Image::New();
ipsegmentationModifiedSlice->Initialize( CastToImageDescriptor( picSlice ) );
ipsegmentationModifiedSlice->SetSlice( picSlice->data );
AccessFixedDimensionByItk_2( sliceImage, ItkCopyFilledContourToSlice, 2, ipsegmentationModifiedSlice, paintingPixelValue );
ipsegmentationModifiedSlice = NULL; // free MITK header information
ipMITKSegmentationFree( picSlice ); // free actual memory
}
void mitk::CLUtil::GaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed ,double sigma)
{
AccessFixedDimensionByItk_2(image, mitk::CLUtil::itkGaussianFilter,3, smoothed, sigma);
}
void mitk::CLUtil::InterpolateCheckerboardPrediction(mitk::Image::Pointer checkerboard_prediction, mitk::Image::Pointer & checkerboard_mask, mitk::Image::Pointer & outimage)
{
AccessFixedDimensionByItk_2(checkerboard_prediction, mitk::CLUtil::itkInterpolateCheckerboardPrediction,3, checkerboard_mask, outimage);
}
void mitk::CLUtil::LogicalAndImages(const mitk::Image::Pointer & image1, const mitk::Image::Pointer & image2, mitk::Image::Pointer & outimage)
{
AccessFixedDimensionByItk_2(image1,itkLogicalAndImages, 3, image2, outimage);
}
void mitk::CLUtil::GrabLabel(mitk::Image::Pointer & image, mitk::Image::Pointer & outimage, unsigned int label)
{
AccessFixedDimensionByItk_2(image, mitk::CLUtil::itkGrabLabel, 3, outimage, label);
}
void BoundingObjectCutter::ComputeData(mitk::Image* input3D, int boTimeStep)
{
AccessFixedDimensionByItk_2(input3D, CutImage, 3, this, boTimeStep);
}
void mitk::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
{
mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
mitk::DataNode *workingDataNode = m_ToolManager->GetWorkingData(0);
if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
{
this->ResetToStartState();
return;
}
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
int timestep = positionEvent->GetSender()->GetTimeStep();
m_Contour = mitk::ContourModel::New();
m_Contour->Expand(timestep + 1);
m_ContourModelNode = mitk::DataNode::New();
m_ContourModelNode->SetData(m_Contour);
m_ContourModelNode->SetName("working contour node");
m_ContourModelNode->SetProperty("layer", IntProperty::New(100));
m_ContourModelNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_ContourModelNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_ContourModelNode->AddProperty("contour.color", ColorProperty::New(1, 1, 0), NULL, true);
m_ContourModelNode->AddProperty("contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true);
m_ContourModelNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), NULL, true);
m_LiveWireContour = mitk::ContourModel::New();
m_LiveWireContour->Expand(timestep + 1);
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true);
m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0), NULL, true);
m_EditingContour = mitk::ContourModel::New();
m_EditingContour->Expand(timestep + 1);
m_EditingContourNode = mitk::DataNode::New();
m_EditingContourNode->SetData(m_EditingContour);
m_EditingContourNode->SetName("editing node");
m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true);
m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true);
m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0), NULL, true);
m_ToolManager->GetDataStorage()->Add(m_ContourModelNode, workingDataNode);
m_ToolManager->GetDataStorage()->Add(m_LiveWireContourNode, workingDataNode);
m_ToolManager->GetDataStorage()->Add(m_EditingContourNode, workingDataNode);
// set current slice as input for ImageToLiveWireContourFilter
m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
mitk::Point3D newOrigin = m_WorkingSlice->GetSlicedGeometry()->GetOrigin();
m_WorkingSlice->GetSlicedGeometry()->WorldToIndex(newOrigin, newOrigin);
m_WorkingSlice->GetSlicedGeometry()->IndexToWorld(newOrigin, newOrigin);
m_WorkingSlice->GetSlicedGeometry()->SetOrigin(newOrigin);
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetInput(m_WorkingSlice);
// map click to pixel coordinates
mitk::Point3D click = positionEvent->GetPositionInWorld();
itk::Index<3> idx;
m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
// get the pixel the gradient in region of 5x5
itk::Index<3> indexWithHighestGradient;
AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
// itk::Index to mitk::Point3D
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
// set initial start point
m_Contour->AddVertex(click, true, timestep);
m_LiveWireFilter->SetStartPoint(click);
// remember plane geometry to determine if events were triggered in same plane
m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
m_CreateAndUseDynamicCosts = true;
// render
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
int mitkPicFileIOTest(int, char*[])
{
unsigned int numberFailed(0);
for (unsigned int i = 0; i < numberOfTestImages; ++i)
{
mitk::Image::Pointer originalImage = CreateTestImage(i);
mitk::Image::Pointer secondImage;
// write
try
{
mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
imageWriter->SetInput(originalImage);
imageWriter->SetFileName("test_image");
imageWriter->SetExtension(".pic");
imageWriter->Write();
}
catch ( std::exception& e )
{
std::cerr << "Error during attempt to write 'test_image.pic' Exception says:" << std::endl;
std::cerr << e.what() << std::endl;
++numberFailed;
continue;
}
// load
try
{
mitk::PicFileReader::Pointer imageReader = mitk::PicFileReader::New();
imageReader->SetFileName("test_image.pic");
imageReader->Update();
secondImage = imageReader->GetOutput();
}
catch ( std::exception& e )
{
std::cerr << "Error during attempt to read 'test_image.pic' Exception says:" << std::endl;
std::cerr << e.what() << std::endl;
++numberFailed;
continue;
}
if (secondImage.IsNull())
{
std::cerr << "Error reading 'test_image.pic'. No image created." << std::endl;
++numberFailed;
continue;
}
std::remove( "test_image.pic" );
// compare
bool identical(false);
AccessFixedDimensionByItk_2( secondImage.GetPointer(), ItkImageProcessing, 3, originalImage.GetPointer(), identical );
if (!identical)
{
std::cerr << "Images differ for testimage " << i << std::endl;
++numberFailed;
continue;
}
}
// if one fails, whole test fails
if (numberFailed > 0)
{
std::cout << "[FAILED]: " << numberFailed << " of " << numberOfTestImages << " sub-tests failed." << std::endl;
return EXIT_FAILURE;
}
else
{
std::cout << "[PASSED]" << std::endl;
return EXIT_SUCCESS;
}
}
