// Reduce contours with Douglas Peucker
void TestComputeNormalsWithHole()
{
mitk::Image::Pointer segmentationImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/LiverSegmentation.nrrd"));
mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/ComputeNormals/ContourWithHoles.vtk"));
m_ContourNormalsFilter->SetInput(contour);
m_ContourNormalsFilter->SetSegmentationBinaryImage(segmentationImage);
m_ContourNormalsFilter->Update();
mitk::Surface::Pointer contourWithNormals = m_ContourNormalsFilter->GetOutput();
mitk::Surface::Pointer normals = m_ContourNormalsFilter->GetNormalsAsSurface();
mitk::Surface::Pointer contourReference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourWithHolesWithNormals.vtk"));
mitk::Surface::Pointer normalsReference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/NormalsWithHoles.vtk"));
CPPUNIT_ASSERT_MESSAGE("Error computing normals", mitk::Equal(*(normals->GetVtkPolyData()), *(normalsReference->GetVtkPolyData()), 0.000001, true));
CPPUNIT_ASSERT_MESSAGE("Error computing normals",
contourWithNormals->GetVtkPolyData()->GetCellData()->GetNormals()->GetNumberOfTuples() == contourReference->GetVtkPolyData()->GetNumberOfPoints());
}
void setUp() override
{
mitk::Image::Pointer regularImage =
mitk::ImageGenerator::GenerateRandomImage<int>(50, 50, 50, 1, 1, 1, 1, 0.3, 0.2);
m_LabelSetImage = dynamic_cast<mitk::LabelSetImage *>(
mitk::IOUtil::Load(GetTestDataFilePath("Multilabel/EmptyMultiLabelSegmentation.nrrd"))[0].GetPointer());
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
mitk::Label::PixelType value1 = 1;
label1->SetValue(value1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
mitk::Label::PixelType value2 = 2;
label2->SetValue(value2);
m_Surface = mitk::IOUtil::Load<mitk::Surface>(GetTestDataFilePath("BallBinary30x30x30Reference.vtp"));
}
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 setUp() override
{
m_UnstructuredGrid = mitk::UnstructuredGrid::New();
// Loading the test data
std::vector<mitk::BaseData::Pointer> vector =
mitk::IOUtil::Load(GetTestDataFilePath("UnstructuredGrid/scoredGrid.vtu"));
mitk::BaseData::Pointer base = vector.at(0);
m_UnstructuredGrid = dynamic_cast<mitk::UnstructuredGrid *>(base.GetPointer());
}
/*
Train the classifier with the dataset of breastcancer patients from the
LibSVM Libary
*/
void TrainSVMClassifier_BreastCancerDataSet_shouldReturnTrue()
{
/* Declarating an featurematrixdataset, the first matrix
of the matrixpair is the trainingmatrix and the second one is the testmatrix.*/
std::pair<MatrixDoubleType,MatrixDoubleType> matrixDouble;
matrixDouble = convertCSVToMatrix<double>(GetTestDataFilePath("Classification/FeaturematrixBreastcancer.csv"),';',0.5,true);
m_TrainingMatrixX = matrixDouble.first;
m_TestXPredict = matrixDouble.second;
/* The declaration of the labelmatrixdataset is equivalent to the declaration
of the featurematrixdataset.*/
std::pair<MatrixIntType,MatrixIntType> matrixInt;
matrixInt = convertCSVToMatrix<int>(GetTestDataFilePath("Classification/LabelmatrixBreastcancer.csv"),';',0.5,false);
m_TrainingLabelMatrixY = matrixInt.first;
m_TestYPredict = matrixInt.second;
/* Setting of the SVM-Parameters*/
classifier = mitk::LibSVMClassifier::New();
classifier->SetGamma(1/(double)(m_TrainingMatrixX.cols()));
classifier->SetSvmType(0);
classifier->SetKernelType(2);
/* Train the classifier, by giving trainingdataset for the labels and features.
The result in an colunmvector of the labels.*/
classifier->Train(m_TrainingMatrixX,m_TrainingLabelMatrixY);
Eigen::MatrixXi classes = classifier->Predict(m_TestXPredict);
/* Testing the matching between the calculated colunmvector and the result
of the SVM */
unsigned int maxrows = classes.rows();
bool isYPredictVector = false;
int count = 0;
for(int i= 0; i < maxrows; i++){
if(classes(i,0) == m_TestYPredict(i,0)){
isYPredictVector = true;
count++;
}
}
MITK_INFO << 100*count/(double)(maxrows) << "%";
MITK_TEST_CONDITION(isIntervall<int>(m_TestYPredict,classes,75,100),"Testvalue is in range.");
}
void Default3D()
{
mitk::RenderingTestHelper renderingHelper(640, 480);
renderingHelper.AddNodeToStorage(node);
renderingHelper.SetMapperIDToRender3D();
renderingHelper.SaveReferenceScreenShot(mitk::IOUtil::GetTempPath()+"fib_3D.png");
mitk::Image::Pointer test_image = mitk::IOUtil::Load<mitk::Image>(mitk::IOUtil::GetTempPath()+"fib_3D.png");
mitk::Image::Pointer ref_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/Rendering/fib_3D.png"));
MITK_ASSERT_EQUAL(test_image, ref_image, "Check if images are equal.");
}
void setUp() override
{
fib1 = NULL;
fib2 = NULL;
std::string filename = GetTestDataFilePath("DiffusionImaging/fiberBundleX.fib");
std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load( filename);
mitk::BaseData::Pointer baseData = fibInfile.at(0);
fib1 = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
}
void setUp(void)
{
// Load Image Data
m_Image = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(m_Image,m_ItkImage);
// Create a single mask with only one pixel within the regions
mitk::Image::Pointer mask1 = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(mask1,m_ItkMask);
m_ItkMask->FillBuffer(0);
MaskType::IndexType index;
index[0]=88;index[1]=81;index[2]=13;
m_ItkMask->SetPixel(index, 1);
MITK_INFO << "Pixel Value: "<<m_ItkImage->GetPixel(index);
mitk::CastToMitkImage(m_ItkMask, m_Mask);
// Create a mask with a covered region
mitk::Image::Pointer lmask1 = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(lmask1,m_ItkMask1);
m_ItkMask1->FillBuffer(0);
int range=2;
for (int x = 88-range;x < 88+range+1;++x)
{
for (int y=81-range;y<81+range+1;++y)
{
for (int z=13-range;z<13+range+1;++z)
{
index[0] = x;
index[1] = y;
index[2] = z;
//MITK_INFO << "Pixel: " <<m_ItkImage->GetPixel(index);
m_ItkMask1->SetPixel(index, 1);
}
}
}
mitk::CastToMitkImage(m_ItkMask1, m_Mask1);
m_GradientImage=GenerateGradientWithDimXImage<unsigned char>(5,5,5);
m_GradientMask = GenerateMaskImage<unsigned char>(5,5,5);
}
void LoadData(std::deque<mitk::ContourModelSet::Pointer> &r)
{
std::vector<itk::SmartPointer<mitk::BaseData> > readerOutput;
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/BODY.cnt_set"));
mitk::ContourModelSet::Pointer cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("BODY"));
r.push_back(cnt_set);
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/Bladder.cnt_set"));
cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("Bladder"));
r.push_back(cnt_set);
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/Femoral Head Lt.cnt_set"));
cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("Femoral Head Lt"));
r.push_back(cnt_set);
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/Femoral Head RT.cnt_set"));
cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("Femoral Head RT"));
r.push_back(cnt_set);
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/PTV.cnt_set"));
cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("PTV"));
r.push_back(cnt_set);
readerOutput = mitk::IOUtil::Load(GetTestDataFilePath("RT/StructureSet/Rectum.cnt_set"));
cnt_set = dynamic_cast<mitk::ContourModelSet*>(readerOutput.at(0).GetPointer());
cnt_set->SetProperty("name", mitk::StringProperty::New("Rectum"));
r.push_back(cnt_set);
}
void setUp()
{
std::string dirName = MITK_TOF_DATA_DIR;
std::string depthImagePath = dirName + "/" + "Kinect_Lego_Phantom_DistanceImage.nrrd";
std::string colorImagePath = dirName + "/" + "Kinect_Lego_Phantom_RGBImage.nrrd";
std::string distanceImageP = dirName + "/" + "PMDCamCube2_MF0_IT0_1Images_DistanceImage.pic";
std::string amplitudeImage = dirName + "/" + "PMDCamCube2_MF0_IT0_1Images_AmplitudeImage.pic";
std::string intensityImage = dirName + "/" + "PMDCamCube2_MF0_IT0_1Images_IntensityImage.pic";
m_KinectDepthImagePath = GetTestDataFilePath(depthImagePath);
m_KinectColorImagePath = GetTestDataFilePath(colorImagePath);
m_CamCubeDepthImagePath = GetTestDataFilePath(distanceImageP);
m_CamCubeIntensityImagePath = GetTestDataFilePath(amplitudeImage);
m_CamCubeAmplitudeImagePath = GetTestDataFilePath(intensityImage);
m_ToFImageGrabber = mitk::ToFImageGrabber::New();
//The Grabber always needs a device
mitk::ToFCameraMITKPlayerDevice::Pointer tofCameraMITKPlayerDevice = mitk::ToFCameraMITKPlayerDevice::New();
m_ToFImageGrabber->SetCameraDevice(tofCameraMITKPlayerDevice);
}
void TestDoseImage()
{
mitk::Image::Pointer refImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("RT/Dose/RT_Dose.nrrd"));
mitk::DataNode::Pointer node = m_rtDoseReader->LoadRTDose(GetTestDataFilePath("RT/Dose/RD.dcm").c_str());
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
MITK_ASSERT_EQUAL(refImage, image, "reference-Image and image should be equal");
auto prescibedDoseProperty = image->GetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str());
auto prescribedDoseGenericProperty = dynamic_cast<mitk::GenericProperty<double>*>(prescibedDoseProperty.GetPointer());
double actualPrescribedDose = prescribedDoseGenericProperty->GetValue();
double expectedPrescribedDose = 65535 * 0.0010494648*0.8;
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("prescribed dose property is not as expected", actualPrescribedDose, expectedPrescribedDose, 1e-5);
float actualReferenceDose;
auto referenceDoseProperty = node->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), actualReferenceDose);
float expectedReferenceDose = 40;
CPPUNIT_ASSERT_EQUAL_MESSAGE("reference dose property is not as expected", static_cast<float>(actualReferenceDose), expectedReferenceDose);
}
void ImageCastToItk_TestImage_Success()
{
itk::Image<short, 3>::Pointer itkImage;
std::string m_ImagePath = GetTestDataFilePath("Pic3D.nrrd");
mitk::Image::Pointer testDataImage = mitk::IOUtil::LoadImage(m_ImagePath);
mitk::CastToItkImage(testDataImage, itkImage);
mitk::Image::Pointer mitkImageAfterCast = mitk::ImportItkImage(itkImage);
// dereference itk image
itkImage = 0;
MITK_ASSERT_EQUAL(mitkImageAfterCast, testDataImage, "Cast with test data followed by import produces same images");
}
void TestRestartWithNewNavigationDataSet()
{
player->SetNavigationDataSet(NavigationDataSet);
mitk::NavigationData::PositionType nd1 = player->GetOutput(0)->GetPosition();
player->SetNavigationDataSet(NavigationDataSet);
mitk::NavigationData::PositionType nd2 = player->GetOutput(0)->GetPosition();
MITK_TEST_CONDITION(nd1 == nd2, "First output must be the same after setting same navigation data again.");
// setting new NavigationDataSet with different tool count should result in an exception
std::string file = GetTestDataFilePath("IGT-Data/NavigationDataTestData.xml");
mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
MITK_TEST_FOR_EXCEPTION(mitk::IGTException, player->SetNavigationDataSet(reader->Read(file)));
}
void Ribbon3D()
{
node->SetBoolProperty( "light.enable_light", true);
node->SetFloatProperty("shape.ribbonwidth", 1);
mitk::RenderingTestHelper renderingHelper(640, 480);
renderingHelper.AddNodeToStorage(node);
renderingHelper.SetMapperIDToRender3D();
renderingHelper.SaveReferenceScreenShot(mitk::IOUtil::GetTempPath()+"fib_ribbon_3D.png");
mitk::Image::Pointer test_image = mitk::IOUtil::Load<mitk::Image>(mitk::IOUtil::GetTempPath()+"fib_ribbon_3D.png");
mitk::Image::Pointer ref_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/Rendering/fib_ribbon_3D.png"));
MITK_ASSERT_EQUAL(test_image, ref_image, "Check if images are equal.");
}
// Compute the normals for a regular contour
void TestComputeNormals()
{
mitk::Surface::Pointer contour =
mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/SingleContour.vtk"));
m_ContourNormalsFilter->SetInput(contour);
m_ContourNormalsFilter->Update();
// Get the computed normals (basically lines)
mitk::Surface::Pointer normals = m_ContourNormalsFilter->GetNormalsAsSurface();
// Get the actual surface object which has the contours stored as normals internally
mitk::Surface::Pointer contourWithNormals = m_ContourNormalsFilter->GetOutput();
mitk::Surface::Pointer referenceContour =
mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourWithNormals.vtk"));
mitk::Surface::Pointer referenceNormals =
mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourNormals.vtk"));
CPPUNIT_ASSERT_MESSAGE(
"Unequal contours",
mitk::Equal(*(contourWithNormals->GetVtkPolyData()), *(referenceContour->GetVtkPolyData()), 0.000001, true));
CPPUNIT_ASSERT_MESSAGE(
"Unequal contours",
mitk::Equal(*(normals->GetVtkPolyData()), *(referenceNormals->GetVtkPolyData()), 0.000001, true));
}
void AddPointInteraction()
{
//Path to the reference PointSet
std::string referencePointSetPath = GetTestDataFilePath("InteractionTestData/ReferenceData/PointSetDataInteractor_add_points_in_2D_ref.mps");
//Path to the interaction xml file
std::string interactionXmlPath = GetTestDataFilePath("InteractionTestData/Interactions/PointSetDataInteractor_add_points_in_2D.xml");
//Create test helper to initialize all necessary objects for interaction
mitk::InteractionTestHelper interactionTestHelper(interactionXmlPath);
//Add our test node to the DataStorage of our test helper
interactionTestHelper.AddNodeToStorage(m_TestPointSetNode);
//Start Interaction
interactionTestHelper.PlaybackInteraction();
//Load the reference PointSet
mitk::PointSet::Pointer referencePointSet = mitk::IOUtil::LoadPointSet(referencePointSetPath);
//Compare reference with the result of the interaction
MITK_ASSERT_EQUAL(m_TestPointSet, referencePointSet, "");
}
void setUp()
{
mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
std::string path = GetTestDataFilePath("IGT-Data/RecordedNavigationData.xml");
m_NavigationDataSet = reader->Read(path);
m_Player = mitk::NavigationDataSequentialPlayer::New();
m_Player->SetNavigationDataSet(m_NavigationDataSet);
m_Recorder = mitk::NavigationDataRecorder::New();
m_Recorder->SetStandardizeTime(false);
// connect player to recorder
m_Recorder->ConnectTo(m_Player);
}
/**
* @brief Setup Always call this method before each Test-case to ensure
* correct and new intialization of the used members for a new test case.
* (If the members are not used in a test, the method does not need to be called).
*/
void setUp() override
{
mitk::CovarianceMatrixCalculator::Pointer matrixCalculator
= mitk::CovarianceMatrixCalculator::New();
m_MovingSurface = mitk::IOUtil::LoadSurface(GetTestDataFilePath("AICPRegistration/head_green.stl"));
m_FixedSurface = mitk::IOUtil::LoadSurface(GetTestDataFilePath("AICPRegistration/head_red.stl"));
m_TargetsMovingSurface = mitk::IOUtil::LoadPointSet(GetTestDataFilePath("AICPRegistration/targets_head_green.mps"));
m_TargetsFixedSurface = mitk::IOUtil::LoadPointSet(GetTestDataFilePath("AICPRegistration/targets_head_red.mps"));
// compute covariance matrices
matrixCalculator->SetInputSurface(m_MovingSurface);
matrixCalculator->ComputeCovarianceMatrices();
m_SigmasMovingSurface = matrixCalculator->GetCovarianceMatrices();
const double meanVarX = matrixCalculator->GetMeanVariance();
matrixCalculator->SetInputSurface(m_FixedSurface);
matrixCalculator->ComputeCovarianceMatrices();
m_SigmasFixedSurface = matrixCalculator->GetCovarianceMatrices();
const double meanVarY = matrixCalculator->GetMeanVariance();
m_FRENormalizationFactor = sqrt( meanVarX + meanVarY );
}
void Color3D()
{
mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
fib->SetFiberColors(255, 255, 255);
mitk::RenderingTestHelper renderingHelper(640, 480);
renderingHelper.AddNodeToStorage(node);
renderingHelper.SetMapperIDToRender3D();
renderingHelper.GetVtkRenderer()->SetBackground(0.0, 0.0, 0.0);
renderingHelper.SaveReferenceScreenShot(mitk::IOUtil::GetTempPath()+"fib_color_3D.png");
mitk::Image::Pointer test_image = mitk::IOUtil::Load<mitk::Image>(mitk::IOUtil::GetTempPath()+"fib_color_3D.png");
mitk::Image::Pointer ref_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/Rendering/fib_color_3D.png"));
MITK_ASSERT_EQUAL(test_image, ref_image, "Check if images are equal.");
}
// Extract a single contour from a slice
void TestExtractASingleContourFromASlice()
{
m_ContourExtractor->SetInput(m_SliceWithSingleContour);
m_ContourExtractor->Update();
CPPUNIT_ASSERT_MESSAGE("ImageToContourFilter has wrong number of outputs!", m_ContourExtractor->GetNumberOfOutputs() == 1);
mitk::Surface::Pointer contour = m_ContourExtractor->GetOutput();
mitk::Surface::Pointer referenceContour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/SingleContour.vtk"));
CPPUNIT_ASSERT_MESSAGE("Extracted contour has wrong number of points!", contour->GetVtkPolyData()->GetNumberOfPoints() ==
referenceContour->GetVtkPolyData()->GetNumberOfPoints());
CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(contour->GetVtkPolyData()), *(referenceContour->GetVtkPolyData()), 0.000001, true));
}
void RenderSpline()
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(mitk::IOUtil::Load(m_PathToPointSet)[0]);
mitk::SplineVtkMapper3D::Pointer mapper = mitk::SplineVtkMapper3D::New();
node->SetMapper(mitk::BaseRenderer::StandardMapperSlot::Standard3D, mapper);
m_RenderingTestHelper.AddNodeToStorage( node );
m_RenderingTestHelper.SetMapperIDToRender3D();
//reference screenshot for this test
m_CommandlineArgs.push_back(GetTestDataFilePath("RenderingTestData/ReferenceScreenshots/spline_linewidth_1.png"));
//Convert vector of strings to argc/argv
mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs);
CPPUNIT_ASSERT( m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(),arg.GetArgv()) == true);
}
void setUp() override
{
us::ModuleContext* context = us::GetModuleContext();
//Filter all registered devices for an ToFCameraMITKPlayerDevice via device name
std::string filter = "(ToFDeviceName=MITK Player)";
us::ServiceReference<mitk::ToFCameraDevice> serviceRefDevice = context->GetServiceReferences<mitk::ToFCameraDevice>(filter).front();
//Get the actual device
m_PlayerDevice = dynamic_cast<mitk::ToFCameraMITKPlayerDevice*>( context->GetService<mitk::ToFCameraDevice>(serviceRefDevice) );
//during the tests here, we use one special test data set located in MITK-Data
m_PathToDepthData = GetTestDataFilePath("ToF-Data/Kinect_Lego_Phantom_DistanceImage.nrrd");
m_PlayerDevice->SetProperty("DistanceImageFileName",mitk::StringProperty::New(m_PathToDepthData));
//initialize an array with the test data size
unsigned int numberOfPixels = 640*480;
m_DistanceArray = new float[numberOfPixels];
}
/**
* @brief Setup Initialize a fresh rendering test helper and a vector of strings
* to simulate commandline arguments for vtkTesting::Test.
*/
void setUp()
{
m_RenderingTestHelper = mitk::RenderingTestHelper(640, 480);
// disables anti-aliasing which is enabled on several graphics cards and
// causes problems when doing a pixel-wise comparison to a reference image
m_RenderingTestHelper.GetVtkRenderWindow()->SetMultiSamples(0);
m_PathToPointSet = GetTestDataFilePath("InteractionTestData/ReferenceData/PointSetDataInteractor_PointsAdd2d3d.mps");
//Build a command line for the vtkTesting::Test method.
//See VTK documentation and RenderingTestHelper for more information.
//Use the following command line option to save the difference image
//and the test image in some tmp folder
//m_CommandlineArgs.push_back("-T");
//m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/");
m_CommandlineArgs.push_back("-V");
}
void ImageCastToItkAndBack_SamePointer_Success()
{
typedef itk::Image<short, 3> ItkImageType;
ItkImageType::Pointer itkImage = ItkImageType::New();
std::string m_ImagePath = GetTestDataFilePath("Pic3D.nrrd");
mitk::Image::Pointer testDataImage = mitk::IOUtil::LoadImage(m_ImagePath);
// modify ITK image
itk::Matrix<double, 3, 3> dir = itkImage->GetDirection();
dir *= 2;
itkImage->SetDirection(dir);
CPPUNIT_ASSERT_THROW_MESSAGE("No exception thrown for casting back the same memory",
testDataImage = mitk::GrabItkImageMemory(itkImage, testDataImage),
itk::ExceptionObject);
CPPUNIT_ASSERT(testDataImage.IsNotNull());
}
void Result_Match_Expectation()
{
mitk::LabelSetImageSurfaceStampFilter::Pointer filter = mitk::LabelSetImageSurfaceStampFilter::New();
filter->SetSurface(m_Surface);
filter->SetForceOverwrite(true);
filter->SetInput(m_LabelSetImage);
filter->Update();
mitk::LabelSetImage::Pointer result = dynamic_cast<mitk::LabelSetImage *>(
m_LabelSetImage.GetPointer()); // dynamic_cast<mitk::LabelSetImage*>(filter->GetOutput());
// result->DisconnectPipeline();
// mitk::LabelSetImage::Pointer result
// =dynamic_cast<mitk::LabelSetImage*>(m_LabelSetImage->Clone().GetPointer());//dynamic_cast<mitk::LabelSetImage*>(filter->GetOutput());
mitk::LabelSetImage::Pointer expectedResult = dynamic_cast<mitk::LabelSetImage *>(
mitk::IOUtil::Load(GetTestDataFilePath("Multilabel/StampResultBasedOnEmptyML.nrrd"))[0].GetPointer());
MITK_ASSERT_EQUAL(result, expectedResult, "Result after stamping should be equal to the saved version");
}
/**
* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
*/
void setUp()
{
//generate test images
std::string imagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi.dwi");
m_Image = mitk::IOUtil::LoadImage(imagePath);
m_ReferenceImage = NULL;
m_DenoisedImage = mitk::Image::New();
//initialise Filter
m_DenoisingFilter = itk::NonLocalMeansDenoisingFilter<short>::New();
VectorImagetType::Pointer vectorImage;
mitk::CastToItkImage(m_Image,vectorImage);
m_DenoisingFilter->SetInputImage(vectorImage);
m_DenoisingFilter->SetNumberOfThreads(1);
m_DenoisingFilter->SetComparisonRadius(1);
m_DenoisingFilter->SetSearchRadius(1);
m_DenoisingFilter->SetVariance(500);
}
void TestStructureSets()
{
std::deque<mitk::ContourModelSet::Pointer> contourModelVectorCorrect;
std::deque<mitk::ContourModelSet::Pointer> contourModelVectorCorrectSequ;
std::deque<mitk::DataNode::Pointer> contourModelVectorTest;
std::deque<mitk::ContourModelSet::Pointer> contourModelVectorTestDel;
LoadData(contourModelVectorCorrect);
contourModelVectorTest = m_rtStructureReader->ReadStructureSet(GetTestDataFilePath("RT/StructureSet/RS.dcm").c_str());
//Deleting all empty contourmodelsets - empty contourmodelsets cant be
//saved so we have reference for the comparison
for(unsigned int i=0; i<contourModelVectorTest.size();++i)
{
if(dynamic_cast<mitk::ContourModelSet*>(contourModelVectorTest.at(i)->GetData())->GetSize()>0){
contourModelVectorTestDel.push_back(dynamic_cast<mitk::ContourModelSet*>(contourModelVectorTest.at(i)->GetData()));
}
}
//Loop for ordering the loaded contourmodelsets(contourModelVectorCorrect)
for(unsigned int i=0; i<contourModelVectorTestDel.size();++i)
{
mitk::BaseProperty::Pointer name = contourModelVectorTestDel.at(i)->GetProperty("name");
for(unsigned int j=0; j<contourModelVectorCorrect.size();++j)
{
mitk::BaseProperty::Pointer tmp = contourModelVectorCorrect.at(j)->GetProperty("name");
if(tmp->GetValueAsString().compare(name->GetValueAsString()) == 0)
contourModelVectorCorrectSequ.push_back(contourModelVectorCorrect.at(j));
}
}
//Testing wheather the two deques are equal
bool equal = true;
for(unsigned int i=0;i<contourModelVectorCorrectSequ.size();++i)
{
if(!Compare(contourModelVectorCorrectSequ.at(i),contourModelVectorTestDel.at(i)))
equal = false;
}
CPPUNIT_ASSERT(equal);
}
void CompareImages(mitk::PeakImage::ItkPeakImageType::Pointer testImage, std::string name)
{
typedef mitk::ImageToItk< mitk::PeakImage::ItkPeakImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/FiberFit/out/" + name)));
caster->Update();
mitk::PeakImage::ItkPeakImageType::Pointer refImage = caster->GetOutput();
itk::ImageRegionConstIterator< mitk::PeakImage::ItkPeakImageType > it1(testImage, testImage->GetLargestPossibleRegion());
itk::ImageRegionConstIterator< mitk::PeakImage::ItkPeakImageType > it2(refImage, refImage->GetLargestPossibleRegion());
while(!it1.IsAtEnd())
{
if (it2.Get()>0.0001)
{
if (fabs( it1.Get()/it2.Get()-1 )>0.01)
{
itk::ImageFileWriter< mitk::PeakImage::ItkPeakImageType >::Pointer writer = itk::ImageFileWriter< mitk::PeakImage::ItkPeakImageType >::New();
writer->SetInput(testImage);
writer->SetFileName(mitk::IOUtil::GetTempPath()+name);
writer->Update();
MITK_INFO << it1.Get() << " - " << it2.Get();
CPPUNIT_ASSERT_MESSAGE("Peak images should be equal 1", false);
}
}
else if (it1.Get()>0.0001)
{
itk::ImageFileWriter< mitk::PeakImage::ItkPeakImageType >::Pointer writer = itk::ImageFileWriter< mitk::PeakImage::ItkPeakImageType >::New();
writer->SetInput(testImage);
writer->SetFileName(mitk::IOUtil::GetTempPath()+name);
writer->Update();
CPPUNIT_ASSERT_MESSAGE("Peak images should be equal 2", false);
}
++it1;
++it2;
}
}
void Denoise_NLMv_shouldReturnTrue()
{
std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMv.dwi");
m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
m_DenoisingFilter->SetUseRicianAdaption(false);
m_DenoisingFilter->SetUseJointInformation(true);
try
{
m_DenoisingFilter->Update();
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMv should always return the same result.");
}
void TestGoToSnapshotException()
{
//testing GoToSnapShot for exception
mitk::NavigationDataSequentialPlayer::Pointer myTestPlayer2 = mitk::NavigationDataSequentialPlayer::New();
std::string file = GetTestDataFilePath("IGT-Data/NavigationDataTestData_2Tools.xml");
mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
myTestPlayer2->SetNavigationDataSet(reader->Read(file));
bool exceptionThrown2=false;
try
{
unsigned int invalidSnapshot = 1000;
myTestPlayer2->GoToSnapshot(invalidSnapshot);
}
catch(mitk::IGTException)
{
exceptionThrown2=true;
}
MITK_TEST_CONDITION(exceptionThrown2, "Testing if exception is thrown when GoToSnapShot method is called with an index that doesn't exist.");
}
