bool mitkSegmentationInterpolationTestClass::LoadTestImages()
{
std::string filename1 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_manual.pic.gz", "../mitk/Core/Testing/Data/");
if ( filename1.empty() )
{
filename1 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_manual.pic.gz", "Testing/Data/");
}
std::cout << "Found test image (manual slices) in '" << filename1 << "'" << std::endl;
std::string filename2 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_result.pic.gz", "../mitk/Core/Testing/Data/");
if ( filename2.empty() )
{
filename2 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_result.pic.gz", "Testing/Data/");
}
std::cout << "Found test image (reference for interpolation) in '" << filename2 << "'" << std::endl;
if ( filename1.empty() || filename2.empty() )
{
return false;
}
else
{
m_ManualSlices = LoadImage( filename1 );
m_InterpolatedSlices = LoadImage( filename2 );
return ( m_ManualSlices.IsNotNull() && m_InterpolatedSlices.IsNotNull() );
}
return true;
}
void setUp() override
{
m_ReferenceImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("Pic3D.nrrd"));
CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [Pic3D.nrrd]", m_ReferenceImage.IsNotNull());
m_InterpolationController = mitk::SegmentationInterpolationController::GetInstance();
// Create empty segmentation
// Surely there must be a better way to get an image with all zeros?
m_SegmentationImage = mitk::Image::New();
const mitk::PixelType pixelType(mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>());
m_SegmentationImage->Initialize(pixelType, m_ReferenceImage->GetDimension(), m_ReferenceImage->GetDimensions());
m_SegmentationImage->SetClonedTimeGeometry(m_ReferenceImage->GetTimeGeometry());
unsigned int size = sizeof(mitk::Tool::DefaultSegmentationDataType);
for (unsigned int dim = 0; dim < m_SegmentationImage->GetDimension(); ++dim)
{
size *= m_SegmentationImage->GetDimension(dim);
}
mitk::ImageWriteAccessor imageAccessor(m_SegmentationImage);
memset(imageAccessor.GetData(), 0, size);
// Work in the center of the image (Pic3D)
m_CenterPoint = {{ 127, 127, 25 }};
}
void StartSimulation(FiberfoxParameters<double> parameters, FiberBundle::Pointer fiberBundle, mitk::Image::Pointer refImage, string message)
{
itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
tractsToDwiFilter->SetUseConstantRandSeed(true);
tractsToDwiFilter->SetParameters(parameters);
tractsToDwiFilter->SetFiberBundle(fiberBundle);
tractsToDwiFilter->Update();
mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
mitk::DiffusionPropertyHelper propertyHelper( testImage );
propertyHelper.InitializeImage();
if (refImage.IsNotNull())
{
if( static_cast<mitk::GradientDirectionsProperty*>( refImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer().IsNotNull() )
{
ItkDwiType::Pointer itkTestImagePointer = ItkDwiType::New();
mitk::CastToItkImage(testImage, itkTestImagePointer);
ItkDwiType::Pointer itkRefImagePointer = ItkDwiType::New();
mitk::CastToItkImage(refImage, itkRefImagePointer);
bool cond = CompareDwi(itkTestImagePointer, itkRefImagePointer);
if (!cond)
{
MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.dwi");
}
MITK_TEST_CONDITION_REQUIRED(cond, message);
}
}
}
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 mitk::PixelManipulationTool::AddImageToDataStorage(mitk::Image::Pointer image)
{
if (image.IsNotNull())
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
std::string name = m_OriginalImageNode->GetName();
name.append("_modified");
node->SetName(name);
node->SetProperty("binary", mitk::BoolProperty::New(false));
node->SetData(image);
if (m_ToolManager)
m_ToolManager->GetDataStorage()->Add(node, m_OriginalImageNode);
}
}
void setUp()
{
//Load the image
//TODO Move/create segmentation subfolder
m_EmptySlice = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/EmptySlice.nrrd"));
CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [EmptySlice.nrrd]", m_EmptySlice.IsNotNull());
m_SliceWithSingleContour = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/SliceWithSingleContour.nrrd"));
CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [SliceWithSingleContour.nrrd]", m_SliceWithSingleContour.IsNotNull());
m_SliceWithTwoContours = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/SliceWithTwoContours.nrrd"));
CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [SliceWithTwoContours.nrrd]", m_SliceWithTwoContours.IsNotNull());
m_ContourExtractor = mitk::ImageToContourFilter::New();
CPPUNIT_ASSERT_MESSAGE("Failed to initialize ImageToContourFilter", m_ContourExtractor.IsNotNull());
}
return imgMem;
}
//#############################################################################
//##################### test methods ##########################################
//#############################################################################
void TestCastingMITKIntITKFloat_EmptyImage()
{
MITK_TEST_OUTPUT(<<"Testing cast of empty MITK(int) to ITK(float) image and back ...");
mitk::Image::Pointer imgMem = GetEmptyTestImageWithGeometry(mitk::MakeScalarPixelType<int>());
itk::Image<float,3>::Pointer itkImage;
mitk::CastToItkImage( imgMem, itkImage );
mitk::Image::Pointer mitkImageAfterCast = mitk::ImportItkImage(itkImage);
MITK_TEST_CONDITION_REQUIRED(mitkImageAfterCast.IsNotNull(),"Checking if result is not NULL.");
}
void TestCastingMITKDoubleITKFloat_EmptyImage()
{
MITK_TEST_OUTPUT(<<"Testing cast of empty MITK(double) to ITK(float) image and back ...");
mitk::Image::Pointer imgMem=GetEmptyTestImageWithGeometry(mitk::MakeScalarPixelType<double>());
itk::Image<itk::DiffusionTensor3D<float>,3>::Pointer diffImage;
mitk::CastToItkImage( imgMem, diffImage );
MITK_TEST_CONDITION_REQUIRED(diffImage.IsNotNull(),"Checking if result is not NULL.");
}
void TestCastingMITKFloatITKFloat_EmptyImage()
{
MITK_TEST_OUTPUT(<<"Testing cast of empty MITK(float) to ITK(float) image and back ...");
mitk::Image::Pointer imgMem=GetEmptyTestImageWithGeometry(mitk::MakeScalarPixelType<float>());
void PartialVolumeAnalysisClusteringCalculator::InternalQuantify(
const itk::Image< TPixel, VImageDimension > *image,
mitk::Image::Pointer clusteredImage, double* retval, mitk::Image::Pointer mask ) const
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< float, VImageDimension > ProbImageType;
typedef itk::Image< unsigned char, VImageDimension > MaskImageType;
typedef mitk::ImageToItk<ProbImageType> CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput( clusteredImage );
castFilter->Update();
typename ProbImageType::Pointer clusterImage = castFilter->GetOutput();
typename MaskImageType::Pointer itkmask = 0;
if(mask.IsNotNull())
{
typedef mitk::ImageToItk<MaskImageType> CastFilterType2;
typename CastFilterType2::Pointer castFilter2 = CastFilterType2::New();
castFilter2->SetInput( mask );
castFilter2->Update();
itkmask = castFilter2->GetOutput();
}
else
{
itkmask = MaskImageType::New();
itkmask->SetSpacing( clusterImage->GetSpacing() ); // Set the image spacing
itkmask->SetOrigin( clusterImage->GetOrigin() ); // Set the image origin
itkmask->SetDirection( clusterImage->GetDirection() ); // Set the image direction
itkmask->SetRegions( clusterImage->GetLargestPossibleRegion() );
itkmask->Allocate();
itkmask->FillBuffer(1);
}
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ProbImageType>
itprob(clusterImage, clusterImage->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<MaskImageType>
itmask(itkmask, itkmask->GetLargestPossibleRegion());
itimage.GoToBegin();
itprob.GoToBegin();
itmask.GoToBegin();
double totalProb = 0;
double measurement = 0;
double error = 0;
while( !itimage.IsAtEnd() && !itprob.IsAtEnd() && !itmask.IsAtEnd() )
{
double valImag = itimage.Get();
double valProb = itprob.Get();
double valMask = itmask.Get();
typename ProbImageType::PixelType prop = valProb * valMask;
totalProb += prop;
measurement += valImag * prop;
error += valImag * valImag * prop;
++itimage;
++itprob;
++itmask;
}
measurement = measurement / totalProb;
error = error / totalProb;
retval[0] = measurement;
retval[1] = sqrt( error - measurement*measurement );
}