diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp index 284a762722..c1fb6d64cf 100644 --- a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp +++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp @@ -1,969 +1,1197 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkImageStatisticsCalculator.h" #include #include #include #include #include #include #include #include #include #include #include #include /** * \brief Test class for mitkImageStatisticsCalculator * * This test covers: * - instantiation of an ImageStatisticsCalculator class * - correctness of statistics when using PlanarFigures for masking */ class mitkImageStatisticsCalculatorTestSuite : public mitk::TestFixture { CPPUNIT_TEST_SUITE(mitkImageStatisticsCalculatorTestSuite); MITK_TEST(TestUninitializedImage); MITK_TEST(TestCase1); MITK_TEST(TestCase2); MITK_TEST(TestCase3); MITK_TEST(TestCase4); MITK_TEST(TestCase5); MITK_TEST(TestCase6); MITK_TEST(TestCase7); MITK_TEST(TestCase8); MITK_TEST(TestCase9); MITK_TEST(TestCase10); MITK_TEST(TestCase11); MITK_TEST(TestCase12); MITK_TEST(TestPic3DCroppedNoMask); MITK_TEST(TestPic3DCroppedBinMask); MITK_TEST(TestPic3DCroppedMultilabelMask); MITK_TEST(TestPic3DCroppedPlanarFigure); - MITK_TEST(TestUS4DCroppedNoMask); + MITK_TEST(TestUS4DCroppedNoMaskTimeStep1); MITK_TEST(TestUS4DCroppedBinMask); MITK_TEST(TestUS4DCroppedMultilabelMask); MITK_TEST(TestUS4DCroppedPlanarFigure); CPPUNIT_TEST_SUITE_END(); public: void TestUninitializedImage(); void TestCase1(); void TestCase2(); void TestCase3(); void TestCase4(); void TestCase5(); void TestCase6(); void TestCase7(); void TestCase8(); void TestCase9(); void TestCase10(); void TestCase11(); void TestCase12(); void TestPic3DCroppedNoMask(); void TestPic3DCroppedBinMask(); void TestPic3DCroppedMultilabelMask(); void TestPic3DCroppedPlanarFigure(); - void TestUS4DCroppedNoMask(); + void TestUS4DCroppedNoMaskTimeStep1(); void TestUS4DCroppedBinMask(); void TestUS4DCroppedMultilabelMask(); void TestUS4DCroppedPlanarFigure(); private: mitk::Image::ConstPointer m_TestImage; mitk::Image::ConstPointer m_Pic3DCroppedImage; mitk::Image::Pointer m_Pic3DCroppedBinMask; mitk::Image::Pointer m_Pic3DCroppedMultilabelMask; mitk::PlanarFigure::Pointer m_Pic3DCroppedPlanarFigure; mitk::Image::ConstPointer m_US4DCroppedImage; mitk::Image::Pointer m_US4DCroppedBinMask; mitk::Image::Pointer m_US4DCroppedMultilabelMask; mitk::PlanarFigure::Pointer m_US4DCroppedPlanarFigure; mitk::PlaneGeometry::Pointer m_Geometry; // calculate statistics for the given image and planarpolygon const mitk::ImageStatisticsContainer::Pointer ComputeStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::Pointer polygon); // calculate statistics for the given image and mask const mitk::ImageStatisticsContainer::Pointer ComputeStatistics(mitk::Image::ConstPointer image, mitk::Image::Pointer image_mask); // universal function to calculate statistics const mitk::ImageStatisticsContainer::Pointer ComputeStatisticsNew(mitk::Image::ConstPointer image, mitk::MaskGenerator::Pointer maskGen = nullptr, mitk::MaskGenerator::Pointer secondardMaskGen = nullptr, unsigned short label = 1); void VerifyStatistics(mitk::ImageStatisticsContainer::StatisticsObject stats, double testMean, double testSD, double testMedian = 0); void VerifyStatistics(mitk::ImageStatisticsContainer::StatisticsObject stats, unsigned long N, double mean, - double MPP, - double median, + //double MPP, + //double median, double skewness, double kurtosis, - double uniformity, - double UPP, + //double uniformity, + //double UPP, double variance, double stdev, double min, double max, double RMS, - double entropy, + //double entropy, vnl_vector minIndex, vnl_vector maxIndex); }; void mitkImageStatisticsCalculatorTestSuite::TestUninitializedImage() { /***************************** * loading uninitialized image to datastorage ******************************/ MITK_INFO << std::endl << "Test uninitialized image: -----------------------------------------------------------------------------------"; CPPUNIT_ASSERT_THROW( mitk::Image::Pointer image = mitk::Image::New(); mitk::DataNode::Pointer node = mitk::DataNode::New(); node->SetData(image); mitk::ImageStatisticsCalculator::Pointer is = mitk::ImageStatisticsCalculator::New(); is->GetStatistics(), mitk::Exception); } void mitkImageStatisticsCalculatorTestSuite::TestCase1() { /***************************** * one whole white pixel * -> mean of 255 expected ******************************/ MITK_INFO << std::endl << "Test case 1:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 10.5; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 10.5; pnt4[1] = 4.5; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 255.0, 0.0, 255.0); } void mitkImageStatisticsCalculatorTestSuite::TestCase2() { /***************************** * half pixel in x-direction (white) * -> mean of 255 expected ******************************/ MITK_INFO << std::endl << "Test case 2:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 10.0; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 10.0; pnt4[1] = 4.5; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 255.0, 0.0, 255.0); } void mitkImageStatisticsCalculatorTestSuite::TestCase3() { /***************************** * half pixel in diagonal-direction (white) * -> mean of 255 expected ******************************/ MITK_INFO << std::endl << "Test case 3:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 10.5; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5; figure1->SetControlPoint(2, pnt3, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 255.0, 0.0, 255.0); } void mitkImageStatisticsCalculatorTestSuite::TestCase4() { /***************************** * one pixel (white) + 2 half pixels (white) + 1 half pixel (black) * -> mean of 191.25 expected ******************************/ MITK_INFO << std::endl << "Test case 4:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 1.1; pnt1[1] = 1.1; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 2.0; pnt2[1] = 2.0; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 3.0; pnt3[1] = 1.0; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 2.0; pnt4[1] = 0.0; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 191.25, 110.41, 242.250); } void mitkImageStatisticsCalculatorTestSuite::TestCase5() { /***************************** * whole pixel (white) + half pixel (gray) in x-direction * -> mean of 191.5 expected ******************************/ MITK_INFO << std::endl << "Test case 5:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 191.50, 63.50, 134.340); } void mitkImageStatisticsCalculatorTestSuite::TestCase6() { /***************************** * quarter pixel (black) + whole pixel (white) + half pixel (gray) in x-direction * -> mean of 191.5 expected ******************************/ MITK_INFO << std::endl << "Test case 6:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.25; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.25; pnt3[1] = 4.5; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 191.5, 63.50, 134.340); } void mitkImageStatisticsCalculatorTestSuite::TestCase7() { /***************************** * half pixel (black) + whole pixel (white) + half pixel (gray) in x-direction * -> mean of 127.66 expected ******************************/ MITK_INFO << std::endl << "Test case 7:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New(); figure1->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5; figure1->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.0; pnt2[1] = 3.5; figure1->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 9.0; pnt3[1] = 4.0; figure1->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.0; figure1->SetControlPoint(3, pnt4, true); figure1->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure1.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 127.66, 104.1, 140.250); } void mitkImageStatisticsCalculatorTestSuite::TestCase8() { /***************************** * whole pixel (gray) * -> mean of 128 expected ******************************/ MITK_INFO << std::endl << "Test case 8:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New(); figure2->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5; figure2->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 11.5; figure2->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 11.5; figure2->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5; figure2->SetControlPoint(3, pnt4, true); figure2->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure2.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 128.0, 0.0, 128.0); } void mitkImageStatisticsCalculatorTestSuite::TestCase9() { /***************************** * whole pixel (gray) + half pixel (white) in y-direction * -> mean of 191.5 expected ******************************/ MITK_INFO << std::endl << "Test case 9:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New(); figure2->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5; figure2->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 12.0; figure2->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 12.0; figure2->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5; figure2->SetControlPoint(3, pnt4, true); figure2->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure2.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 191.5, 63.50, 134.340); } void mitkImageStatisticsCalculatorTestSuite::TestCase10() { /***************************** * 2 whole pixel (white) + 2 whole pixel (black) in y-direction * -> mean of 127.66 expected ******************************/ MITK_INFO << std::endl << "Test case 10:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New(); figure2->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5; figure2->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 13.5; figure2->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 13.5; figure2->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5; figure2->SetControlPoint(3, pnt4, true); figure2->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure2.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 127.66, 104.1, 140.250); } void mitkImageStatisticsCalculatorTestSuite::TestCase11() { /***************************** * 9 whole pixels (white) + 3 half pixels (white) * + 3 whole pixel (black) [ + 3 slightly less than half pixels (black)] * -> mean of 204.0 expected ******************************/ MITK_INFO << std::endl << "Test case 11:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New(); figure2->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 0.5; pnt1[1] = 0.5; figure2->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 3.5; pnt2[1] = 3.5; figure2->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 8.4999; pnt3[1] = 3.5; figure2->SetControlPoint(2, pnt3, true); mitk::Point2D pnt4; pnt4[0] = 5.4999; pnt4[1] = 0.5; figure2->SetControlPoint(3, pnt4, true); figure2->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure2.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 204.0, 102.00, 242.250); } void mitkImageStatisticsCalculatorTestSuite::TestCase12() { /***************************** * half pixel (white) + whole pixel (white) + half pixel (black) * -> mean of 212.66 expected ******************************/ MITK_INFO << std::endl << "Test case 12:-----------------------------------------------------------------------------------"; std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm"); m_TestImage = mitk::IOUtil::Load(filename); CPPUNIT_ASSERT_MESSAGE("Failed loading an mitk::Image", m_TestImage.IsNotNull()); m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0); CPPUNIT_ASSERT_MESSAGE("Failed getting image geometry", m_Geometry.IsNotNull()); mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New(); figure2->SetPlaneGeometry(m_Geometry); mitk::Point2D pnt1; pnt1[0] = 9.5; pnt1[1] = 0.5; figure2->PlaceFigure(pnt1); mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 2.5; figure2->SetControlPoint(1, pnt2, true); mitk::Point2D pnt3; pnt3[0] = 11.5; pnt3[1] = 2.5; figure2->SetControlPoint(2, pnt3, true); figure2->GetPolyLine(0); auto statisticsContainer = ComputeStatistics(m_TestImage, figure2.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); this->VerifyStatistics(statisticsObjectTimestep0, 212.66, 59.860, 248.640); } void mitkImageStatisticsCalculatorTestSuite::TestPic3DCroppedNoMask() { MITK_INFO << std::endl << "Test Pic3D cropped without mask:-----------------------------------------------------------------------------------"; std::string Pic3DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_cropped.nrrd"); m_Pic3DCroppedImage = mitk::IOUtil::Load(Pic3DCroppedFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D_cropped", m_Pic3DCroppedImage.IsNotNull()); unsigned long expected_N = 27; double expected_mean = -564.1481481481481481; - double expected_MPP = ; + //double expected_MPP = ; double expected_median = -825; double expected_skewness = 0.7120461106763573; - double expected_kurtosis = 0.0147580505392599; - double expected_uniformity = ; - double expected_UPP = ; + double expected_kurtosis = 1.8794464383714844; + //double expected_uniformity = ; + //double expected_UPP = ; double expected_variance = 140541.38545953357; double expected_standarddev = 374.88849736892911; double expected_min = -927; double expected_max = 147; double expected_RMS = 677.35110431630551; - double expected_entropy = ; + //double expected_entropy = ; vnl_vector expected_minIndex; expected_minIndex.set_size(3); expected_minIndex[0] = 2; expected_minIndex[1] = 1; expected_minIndex[2] = 1; vnl_vector expected_maxIndex; expected_maxIndex.set_size(3); expected_maxIndex[0] = 0; expected_maxIndex[1] = 1; expected_maxIndex[2] = 2; auto statisticsContainer = ComputeStatisticsNew(m_Pic3DCroppedImage); auto statisticsObject = statisticsContainer->GetStatisticsForTimeStep(0); VerifyStatistics(statisticsObject, expected_N, expected_mean, - expected_MPP, - expected_median, + //expected_MPP, + //expected_median, expected_skewness, expected_kurtosis, - expected_uniformity, - expected_UPP, + //expected_uniformity, + //expected_UPP, expected_variance, expected_standarddev, expected_min, expected_max, expected_RMS, - expected_entropy, + //expected_entropy, expected_minIndex, expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestPic3DCroppedBinMask() { MITK_INFO << std::endl << "Test Pic3D cropped binary mask:-----------------------------------------------------------------------------------"; std::string Pic3DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_cropped.nrrd"); m_Pic3DCroppedImage = mitk::IOUtil::Load(Pic3DCroppedFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D_cropped", m_Pic3DCroppedImage.IsNotNull()); - std::string Pic3DCroppedBinMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_croppedbinMask.nrrd"); + std::string Pic3DCroppedBinMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_croppedBinMask.nrrd"); m_Pic3DCroppedBinMask = mitk::IOUtil::Load(Pic3DCroppedBinMaskFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D binary mask", m_Pic3DCroppedBinMask.IsNotNull()); - double expected_entropy = ; - double expected_kurtosis = 0.2745916107263060; - double expected_MPP = ; + //double expected_entropy = ; + double expected_kurtosis = 1.0765697398089618; + //double expected_MPP = ; double expected_max = -22; double expected_mean = -464; - double expected_median = -494; + //double expected_median = -494; double expected_min = -846; unsigned long expected_N = 4; - double expected_RMS = 595.4263178597332200; + double expected_RMS = 595.42631785973322; double expected_skewness = 0.0544059290851858; - double expected_standarddev = 373.1440740518332300; - double expected_UPP = ; - double expected_uniformity = ; + double expected_standarddev = 373.14407405183323; + //double expected_UPP = ; + //double expected_uniformity = ; double expected_variance = 139236.50; vnl_vector expected_minIndex; expected_minIndex.set_size(3); expected_minIndex[0] = 1; expected_minIndex[1] = 0; expected_minIndex[2] = 0; vnl_vector expected_maxIndex; expected_maxIndex.set_size(3); expected_maxIndex[0] = 0; expected_maxIndex[1] = 0; expected_maxIndex[2] = 1; mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New(); imgMaskGen->SetImageMask(m_Pic3DCroppedBinMask); imgMaskGen->SetInputImage(m_Pic3DCroppedImage); imgMaskGen->SetTimeStep(0); auto statisticsContainer = ComputeStatisticsNew(m_Pic3DCroppedImage, imgMaskGen.GetPointer(), nullptr, 1); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); VerifyStatistics(statisticsObjectTimestep0, expected_N, expected_mean, - expected_MPP, - expected_median, + //expected_MPP, + //expected_median, expected_skewness, expected_kurtosis, - expected_uniformity, - expected_UPP, + //expected_uniformity, + //expected_UPP, expected_variance, expected_standarddev, expected_min, expected_max, expected_RMS, - expected_entropy, + //expected_entropy, expected_minIndex, expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestPic3DCroppedMultilabelMask() { MITK_INFO << std::endl << "Test Pic3D cropped multilabel mask:-----------------------------------------------------------------------------------"; std::string Pic3DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_cropped.nrrd"); m_Pic3DCroppedImage = mitk::IOUtil::Load(Pic3DCroppedFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D_cropped", m_Pic3DCroppedImage.IsNotNull()); std::string Pic3DCroppedMultilabelMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_croppedMultilabelMask.nrrd"); m_Pic3DCroppedMultilabelMask = mitk::IOUtil::Load(Pic3DCroppedMultilabelMaskFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D multilabel mask", m_Pic3DCroppedMultilabelMask.IsNotNull()); - double expected_entropy = ; - double expected_kurtosis = ; - double expected_MPP = ; - double expected_max = ; - double expected_mean = ; - double expected_median = ; - double expected_min = ; - unsigned long expected_N = ; - double expected_RMS = ; - double expected_skewness = ; - double expected_standarddev = ; - double expected_UPP = ; - double expected_uniformity = ; - double expected_variance = ; + //double expected_entropy = ; + double expected_kurtosis = 1.5; + //double expected_MPP = ; + double expected_max = 63; + double expected_mean = -455.0; + //double expected_median = ; + double expected_min = -851; + unsigned long expected_N = 3; + double expected_RMS = 594.72654780719745; + double expected_skewness = 0.4455045167373422; + double expected_standarddev = 382.9812876194693; + //double expected_UPP = ; + //double expected_uniformity = ; + double expected_variance = 146674.66666666666; vnl_vector expected_minIndex; expected_minIndex.set_size(3); - expected_minIndex[0] = ; - expected_minIndex[1] = ; - expected_minIndex[2] = ; + expected_minIndex[0] = 2; + expected_minIndex[1] = 2; + expected_minIndex[2] = 2; vnl_vector expected_maxIndex; expected_maxIndex.set_size(3); - expected_maxIndex[0] = ; - expected_maxIndex[1] = ; - expected_maxIndex[2] = ; + expected_maxIndex[0] = 0; + expected_maxIndex[1] = 2; + expected_maxIndex[2] = 2; mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New(); imgMaskGen->SetImageMask(m_Pic3DCroppedMultilabelMask); imgMaskGen->SetInputImage(m_Pic3DCroppedImage); imgMaskGen->SetTimeStep(0); auto statisticsContainer = ComputeStatisticsNew(m_Pic3DCroppedImage, imgMaskGen.GetPointer(), nullptr, 2); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); VerifyStatistics(statisticsObjectTimestep0, expected_N, expected_mean, - expected_MPP, - expected_median, + //expected_MPP, + //expected_median, expected_skewness, expected_kurtosis, - expected_uniformity, - expected_UPP, + //expected_uniformity, + //expected_UPP, expected_variance, expected_standarddev, expected_min, expected_max, expected_RMS, - expected_entropy, + //expected_entropy, expected_minIndex, expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestPic3DCroppedPlanarFigure() { MITK_INFO << std::endl << "Test Pic3D cropped planar figure:-----------------------------------------------------------------------------------"; std::string Pic3DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_cropped.nrrd"); m_Pic3DCroppedImage = mitk::IOUtil::Load(Pic3DCroppedFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D_cropped", m_Pic3DCroppedImage.IsNotNull()); std::string Pic3DCroppedPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D_croppedPF.pf"); m_Pic3DCroppedPlanarFigure = mitk::IOUtil::Load(Pic3DCroppedPlanarFigureFile); CPPUNIT_ASSERT_MESSAGE("Failed loading Pic3D planar figure", m_Pic3DCroppedPlanarFigure.IsNotNull()); - double expected_entropy = ; - double expected_kurtosis = 0.5; - double expected_MPP = ; + //double expected_entropy = ; + double expected_kurtosis = 1; + //double expected_MPP = ; double expected_max = -67; double expected_mean = -446; - double expected_median = -446; + //double expected_median = -446; double expected_min = -825; unsigned long expected_N = 2; double expected_RMS = 585.28369189650243; double expected_skewness = 0; double expected_standarddev = 379; - double expected_UPP = ; - double expected_uniformity = ; + //double expected_UPP = ; + //double expected_uniformity = ; double expected_variance = 143641; vnl_vector expected_minIndex; expected_minIndex.set_size(3); - expected_minIndex[0] = 0; + expected_minIndex[0] = 1; expected_minIndex[1] = 1; expected_minIndex[2] = 1; vnl_vector expected_maxIndex; expected_maxIndex.set_size(3); - expected_maxIndex[0] = 1; + expected_maxIndex[0] = 0; expected_maxIndex[1] = 1; expected_maxIndex[2] = 1; mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New(); pfMaskGen->SetInputImage(m_Pic3DCroppedImage); pfMaskGen->SetPlanarFigure(m_Pic3DCroppedPlanarFigure); auto statisticsContainer = ComputeStatisticsNew(m_Pic3DCroppedImage, pfMaskGen.GetPointer()); auto statisticsObjectTimestep0 = statisticsContainer->GetStatisticsForTimeStep(0); VerifyStatistics(statisticsObjectTimestep0, expected_N, expected_mean, - expected_MPP, - expected_median, + //expected_MPP, + //expected_median, expected_skewness, expected_kurtosis, - expected_uniformity, - expected_UPP, + //expected_uniformity, + //expected_UPP, expected_variance, expected_standarddev, expected_min, expected_max, expected_RMS, - expected_entropy, + //expected_entropy, expected_minIndex, expected_maxIndex); } -void mitkImageStatisticsCalculatorTestSuite::TestUS4DCroppedNoMask() +void mitkImageStatisticsCalculatorTestSuite::TestUS4DCroppedNoMaskTimeStep1() { + MITK_INFO << std::endl << "Test US4D cropped without mask timestep 1:-----------------------------------------------------------------------------------"; + + std::string US4DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_Cropped.nrrd"); + m_US4DCroppedImage = mitk::IOUtil::Load(US4DCroppedFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D", m_US4DCroppedImage.IsNotNull()); + + //double expected_entropy = ; + double expected_kurtosis = 1.5398359155908228; + //double expected_MPP = ; + double expected_max = 199; + double expected_mean = 157.74074074074073; + //double expected_median = 156; + double expected_min = 101; + unsigned long expected_N = 27; + double expected_RMS = 160.99171821349486; + double expected_skewness = 0.034728031350845; + double expected_standarddev = 32.189936997387058; + //double expected_UPP = ; + //double expected_uniformity = ; + double expected_variance = 1036.1920438957479000; + vnl_vector expected_minIndex; + expected_minIndex.set_size(3); + expected_minIndex[0] = 0; + expected_minIndex[1] = 2; + expected_minIndex[2] = 0; + vnl_vector expected_maxIndex; + expected_maxIndex.set_size(3); + expected_maxIndex[0] = 0; + expected_maxIndex[1] = 0; + expected_maxIndex[2] = 1; + + auto statisticsContainer = ComputeStatisticsNew(m_US4DCroppedImage); + auto statisticsObjectTimestep1 = statisticsContainer->GetStatisticsForTimeStep(1); + + VerifyStatistics(statisticsObjectTimestep1, + expected_N, + expected_mean, + //expected_MPP, + //expected_median, + expected_skewness, + expected_kurtosis, + //expected_uniformity, + //expected_UPP, + expected_variance, + expected_standarddev, + expected_min, + expected_max, + expected_RMS, + //expected_entropy, + expected_minIndex, + expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestUS4DCroppedBinMask() { + MITK_INFO << std::endl << "Test US4D cropped with binary mask:-----------------------------------------------------------------------------------"; + + std::string US4DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_cropped.nrrd"); + m_US4DCroppedImage = mitk::IOUtil::Load(US4DCroppedFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D", m_US4DCroppedImage.IsNotNull()); + + std::string US4DCroppedBinMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_croppedBinMask.nrrd"); + m_US4DCroppedBinMask = mitk::IOUtil::Load(US4DCroppedBinMaskFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D image mask", m_US4DCroppedBinMask.IsNotNull()); + + //double expected_entropy = ; + double expected_kurtosis = 1.5863739712889191; + //double expected_MPP = ; + double expected_max = 199; + double expected_mean = 166.75; + //double expected_median = 174; + double expected_min = 120; + unsigned long expected_N = 4; + double expected_RMS = 169.70636405273669; + double expected_skewness = -0.4285540263894276; + double expected_standarddev = 31.538666744172936; + //double expected_UPP = ; + //double expected_uniformity = ; + double expected_variance = 994.6875; + vnl_vector expected_minIndex; + expected_minIndex.set_size(3); + expected_minIndex[0] = 0; + expected_minIndex[1] = 0; + expected_minIndex[2] = 2; + vnl_vector expected_maxIndex; + expected_maxIndex.set_size(3); + expected_maxIndex[0] = 1; + expected_maxIndex[1] = 1; + expected_maxIndex[2] = 1; + + mitk::ImageMaskGenerator::Pointer imgMask1 = mitk::ImageMaskGenerator::New(); + imgMask1->SetInputImage(m_US4DCroppedImage); + imgMask1->SetImageMask(m_US4DCroppedBinMask); + + auto statisticsContainer = ComputeStatisticsNew(m_US4DCroppedImage, imgMask1.GetPointer(), nullptr, 1); + auto statisticsObjectTimestep1 = statisticsContainer->GetStatisticsForTimeStep(1); + + VerifyStatistics(statisticsObjectTimestep1, + expected_N, + expected_mean, + //expected_MPP, + //expected_median, + expected_skewness, + expected_kurtosis, + //expected_uniformity, + //expected_UPP, + expected_variance, + expected_standarddev, + expected_min, + expected_max, + expected_RMS, + //expected_entropy, + expected_minIndex, + expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestUS4DCroppedMultilabelMask() { + MITK_INFO << std::endl << "Test US4D cropped with mulitlabel mask:-----------------------------------------------------------------------------------"; + + std::string US4DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_cropped.nrrd"); + m_US4DCroppedImage = mitk::IOUtil::Load(US4DCroppedFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D", m_US4DCroppedImage.IsNotNull()); + + std::string US4DCroppedMultilabelMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_croppedBinMask.nrrd"); + m_US4DCroppedMultilabelMask = mitk::IOUtil::Load(US4DCroppedMultilabelMaskFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D image mask", m_US4DCroppedMultilabelMask.IsNotNull()); + + //double expected_entropy = ; + double expected_kurtosis = 1.1393414449626009; + //double expected_MPP = ; + double expected_max = 184; + double expected_mean = 105.5; + //double expected_median = ; + double expected_min = 35; + unsigned long expected_N = 4; + double expected_RMS = 123.48076773327901; + double expected_skewness = 0.0658171047698421; + double expected_standarddev = 64.16580085995966; + //double expected_UPP = ; + //double expected_uniformity = ; + double expected_variance = 4117.25; + vnl_vector expected_minIndex; + expected_minIndex.set_size(3); + expected_minIndex[0] = 1; + expected_minIndex[1] = 1; + expected_minIndex[2] = 1; + vnl_vector expected_maxIndex; + expected_maxIndex.set_size(3); + expected_maxIndex[0] = 0; + expected_maxIndex[1] = 1; + expected_maxIndex[2] = 0; + + mitk::ImageMaskGenerator::Pointer imgMask1 = mitk::ImageMaskGenerator::New(); + imgMask1->SetInputImage(m_US4DCroppedImage); + imgMask1->SetImageMask(m_US4DCroppedMultilabelMask); + + auto statisticsContainer = ComputeStatisticsNew(m_US4DCroppedImage, imgMask1.GetPointer(), nullptr, 1); + auto statisticsObjectTimestep1 = statisticsContainer->GetStatisticsForTimeStep(0); + + VerifyStatistics(statisticsObjectTimestep1, + expected_N, + expected_mean, + //expected_MPP, + //expected_median, + expected_skewness, + expected_kurtosis, + //expected_uniformity, + //expected_UPP, + expected_variance, + expected_standarddev, + expected_min, + expected_max, + expected_RMS, + //expected_entropy, + expected_minIndex, + expected_maxIndex); } void mitkImageStatisticsCalculatorTestSuite::TestUS4DCroppedPlanarFigure() { + MITK_INFO << std::endl << "Test US4D cropped planar figure:-----------------------------------------------------------------------------------"; + + std::string US4DCroppedFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_cropped.nrrd"); + m_US4DCroppedImage = mitk::IOUtil::Load(US4DCroppedFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D", m_US4DCroppedImage.IsNotNull()); + + std::string US4DCroppedPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D_croppedPF.pf"); + m_US4DCroppedPlanarFigure = mitk::IOUtil::Load(US4DCroppedPlanarFigureFile); + CPPUNIT_ASSERT_MESSAGE("Loaded US4D coronal planarFigure", m_US4DCroppedPlanarFigure.IsNotNull()); + + //double expected_entropy = ; + double expected_kurtosis = 1; + //double expected_MPP = ; + double expected_max = 197; + double expected_mean = 164; + double expected_median = 164; + double expected_min = 131; + unsigned long expected_N = 2; + double expected_RMS = 167.28717822953436; + double expected_skewness = 0; + //double expected_standarddev = ; + //double expected_UPP = ; + //double expected_uniformity = ; + double expected_variance = 1089; + vnl_vector expected_minIndex; + expected_minIndex.set_size(3); + expected_minIndex[0] = 1; + expected_minIndex[1] = 2; + expected_minIndex[2] = 0; + + vnl_vector expected_maxIndex; + expected_maxIndex.set_size(3); + expected_maxIndex[0] = 1; + expected_maxIndex[1] = 2; + expected_maxIndex[2] = 1; + + mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New(); + pfMaskGen->SetInputImage(m_US4DCroppedImage); + pfMaskGen->SetPlanarFigure(m_US4DCroppedPlanarFigure); + auto statisticsContainer = ComputeStatisticsNew(m_US4DCroppedImage, pfMaskGen.GetPointer()); + auto statisticsObjectTimestep1 = statisticsContainer->GetStatisticsForTimeStep(2); + + VerifyStatistics(statisticsObjectTimestep1, + expected_N, + expected_mean, + //expected_MPP, + expected_median, + expected_skewness, + expected_kurtosis, + //expected_uniformity, + //expected_UPP, + expected_variance, + //expected_standarddev, + expected_min, + expected_max, + expected_RMS, + //expected_entropy, + expected_minIndex, + expected_maxIndex); } const mitk::ImageStatisticsContainer::Pointer mitkImageStatisticsCalculatorTestSuite::ComputeStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::Pointer polygon) { mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New(); statisticsCalculator->SetInputImage(image); statisticsCalculator->SetNBinsForHistogramStatistics(10); mitk::PlanarFigureMaskGenerator::Pointer planFigMaskGen = mitk::PlanarFigureMaskGenerator::New(); planFigMaskGen->SetInputImage(image); planFigMaskGen->SetPlanarFigure(polygon); statisticsCalculator->SetMask(planFigMaskGen.GetPointer()); try { return statisticsCalculator->GetStatistics(); } catch (...) { return nullptr; } } const mitk::ImageStatisticsContainer::Pointer mitkImageStatisticsCalculatorTestSuite::ComputeStatistics(mitk::Image::ConstPointer image, mitk::Image::Pointer image_mask) { mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New(); statisticsCalculator->SetInputImage(image); statisticsCalculator->SetNBinsForHistogramStatistics(10); mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New(); imgMaskGen->SetImageMask(image_mask); statisticsCalculator->SetMask(imgMaskGen.GetPointer()); return statisticsCalculator->GetStatistics(); } const mitk::ImageStatisticsContainer::Pointer mitkImageStatisticsCalculatorTestSuite::ComputeStatisticsNew(mitk::Image::ConstPointer image, mitk::MaskGenerator::Pointer maskGen, mitk::MaskGenerator::Pointer secondardMaskGen, unsigned short label) { mitk::ImageStatisticsCalculator::Pointer imgStatCalc = mitk::ImageStatisticsCalculator::New(); imgStatCalc->SetInputImage(image); if (maskGen.IsNotNull()) { imgStatCalc->SetMask(maskGen.GetPointer()); if (secondardMaskGen.IsNotNull()) { imgStatCalc->SetSecondaryMask(secondardMaskGen.GetPointer()); } } return imgStatCalc->GetStatistics(label); } void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(mitk::ImageStatisticsContainer::StatisticsObject stats, double testMean, double testSD, double testMedian) { auto mean = stats.GetValueConverted(mitk::ImageStatisticsConstants::MEAN()); int tmpMean = mean * 100; double calculatedMean = tmpMean / 100.0; CPPUNIT_ASSERT_MESSAGE("Calculated mean grayvalue is not equal to the desired value.", calculatedMean == testMean); auto standardDeviation = stats.GetValueConverted(mitk::ImageStatisticsConstants::STANDARDDEVIATION()); int tmpSD = standardDeviation * 100; double calculatedSD = tmpSD / 100.0; CPPUNIT_ASSERT_MESSAGE("Calculated grayvalue sd is not equal to the desired value.", calculatedSD == testSD); auto median = stats.GetValueConverted(mitk::ImageStatisticsConstants::MEDIAN()); int tmpMedian = median * 100; double calculatedMedian = tmpMedian / 100.0; CPPUNIT_ASSERT_MESSAGE("Calculated median grayvalue is not equal to the desired value.", testMedian == calculatedMedian); } void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(mitk::ImageStatisticsContainer::StatisticsObject stats, unsigned long N, double mean, - double MPP, - double median, + //double MPP, + //double median, double skewness, double kurtosis, - double uniformity, - double UPP, + //double uniformity, + //double UPP, double variance, double stdev, double min, double max, double RMS, - double entropy, + //double entropy, vnl_vector minIndex, vnl_vector maxIndex) { auto numberOfVoxelsObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::NUMBEROFVOXELS()); auto meanObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MEAN()); - auto mppObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MPP()); - auto medianObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MEDIAN()); + //auto mppObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MPP()); + //auto medianObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MEDIAN()); auto skewnessObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::SKEWNESS()); auto kurtosisObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::KURTOSIS()); - auto uniformityObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::UNIFORMITY()); - auto uppObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::UPP()); + //auto uniformityObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::UNIFORMITY()); + //auto uppObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::UPP()); auto varianceObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::VARIANCE()); auto standardDeviationObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::STANDARDDEVIATION()); auto minObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MINIMUM()); auto maxObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MAXIMUM()); auto rmsObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::RMS()); - auto entropyObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::ENTROPY()); + //auto entropyObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::ENTROPY()); auto minIndexObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MINIMUMPOSITION()); auto maxIndexObject = stats.GetValueConverted(mitk::ImageStatisticsConstants::MAXIMUMPOSITION()); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", numberOfVoxelsObject - N == 0); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(meanObject - mean) < mitk::eps); // in one test case MPP is None because the roi has no positive pixels - if (!std::isnan(mppObject)) + /*if (!std::isnan(mppObject)) { CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(mppObject - MPP) < mitk::eps); - } - CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(medianObject - median) < mitk::eps); + }*/ + //CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(medianObject - median) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(skewnessObject - skewness) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(kurtosisObject - kurtosis) < mitk::eps); - CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(uniformityObject - uniformity) < mitk::eps); - CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(uppObject - UPP) < mitk::eps); + //CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(uniformityObject - uniformity) < mitk::eps); + //CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(uppObject - UPP) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(varianceObject - variance) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(standardDeviationObject - stdev) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(minObject - min) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(maxObject - max) < mitk::eps); CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(rmsObject - RMS) < mitk::eps); - CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(entropyObject - entropy) < mitk::eps); + //CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(entropyObject - entropy) < mitk::eps); for (unsigned int i = 0; i < minIndex.size(); ++i) { CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(minIndexObject[i] - minIndex[i]) < mitk::eps); } for (unsigned int i = 0; i < maxIndex.size(); ++i) { CPPUNIT_ASSERT_MESSAGE("Calculated value does not fit expected value", std::abs(maxIndexObject[i] - maxIndex[i]) < mitk::eps); } } MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsCalculator) \ No newline at end of file