diff --git a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp index f0a8d0981d..78799c862a 100644 --- a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp +++ b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp @@ -1,649 +1,649 @@ /*=================================================================== 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 "mitkInteractionConst.h" #include "mitkPlaneGeometry.h" #include "mitkPlanePositionManager.h" #include "mitkRotationOperation.h" #include "mitkSliceNavigationController.h" #include "mitkSlicedGeometry3D.h" #include "mitkTestingMacros.h" #include "usGetModuleContext.h" #include "usModuleContext.h" #include "usServiceReference.h" #include #include #include bool operator==(const mitk::Geometry3D &left, const mitk::Geometry3D &right) { mitk::BoundingBox::BoundsArrayType leftbounds, rightbounds; leftbounds = left.GetBounds(); rightbounds = right.GetBounds(); unsigned int i; for (i = 0; i < 6; ++i) if (mitk::Equal(leftbounds[i], rightbounds[i]) == false) return false; const mitk::Geometry3D::TransformType::MatrixType &leftmatrix = left.GetIndexToWorldTransform()->GetMatrix(); const mitk::Geometry3D::TransformType::MatrixType &rightmatrix = right.GetIndexToWorldTransform()->GetMatrix(); unsigned int j; for (i = 0; i < 3; ++i) { const mitk::Geometry3D::TransformType::MatrixType::ValueType *leftvector = leftmatrix[i]; const mitk::Geometry3D::TransformType::MatrixType::ValueType *rightvector = rightmatrix[i]; for (j = 0; j < 3; ++j) if (mitk::Equal(leftvector[i], rightvector[i]) == false) return false; } const mitk::Geometry3D::TransformType::OffsetType &leftoffset = left.GetIndexToWorldTransform()->GetOffset(); const mitk::Geometry3D::TransformType::OffsetType &rightoffset = right.GetIndexToWorldTransform()->GetOffset(); for (i = 0; i < 3; ++i) if (mitk::Equal(leftoffset[i], rightoffset[i]) == false) return false; return true; } int compareGeometry(const mitk::TimeGeometry &timeGeometry, const mitk::ScalarType &width, const mitk::ScalarType &height, const mitk::ScalarType &numSlices, const mitk::ScalarType &widthInMM, const mitk::ScalarType &heightInMM, const mitk::ScalarType &thicknessInMM, const mitk::Point3D &cornerpoint0, const mitk::Vector3D &right, const mitk::Vector3D &bottom, const mitk::Vector3D &normal) { // Probleme durch umstellung von Time-SlicedGeometry auf TimeGeometry? // Eventuell gibt es keine Entsprechung mehr. const mitk::BaseGeometry::Pointer geometry = timeGeometry.GetGeometryForTimeStep(0); std::cout << "Testing width, height and thickness (in units): "; if ((mitk::Equal(geometry->GetExtent(0), width) == false) || (mitk::Equal(geometry->GetExtent(1), height) == false) || (mitk::Equal(geometry->GetExtent(2), numSlices) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing width, height and thickness (in mm): "; if ((mitk::Equal(geometry->GetExtentInMM(0), widthInMM) == false) || (mitk::Equal(geometry->GetExtentInMM(1), heightInMM) == false) || (mitk::Equal(geometry->GetExtentInMM(2), thicknessInMM) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing GetAxisVector(): "; std::cout << "dir=0 "; mitk::Vector3D dv; dv = right; dv.Normalize(); dv *= widthInMM; if ((mitk::Equal(geometry->GetAxisVector(0), dv) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]"; std::cout << ", dir=1 "; dv = bottom; dv.Normalize(); dv *= heightInMM; if ((mitk::Equal(geometry->GetAxisVector(1), dv) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]"; std::cout << ", dir=2 "; dv = normal; dv.Normalize(); dv *= thicknessInMM; if ((mitk::Equal(geometry->GetAxisVector(2), dv) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing offset: "; if ((mitk::Equal(geometry->GetCornerPoint(0), cornerpoint0, (double)vnl_math::float_eps) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; return EXIT_SUCCESS; } int testGeometry(const mitk::Geometry3D *geometry, const mitk::ScalarType &width, const mitk::ScalarType &height, const mitk::ScalarType &numSlices, const mitk::ScalarType &widthInMM, const mitk::ScalarType &heightInMM, const mitk::ScalarType &thicknessInMM, const mitk::Point3D &cornerpoint0, const mitk::Vector3D &right, const mitk::Vector3D &bottom, const mitk::Vector3D &normal) { int result = EXIT_FAILURE; std::cout << "Comparing GetCornerPoint(0) of Geometry3D with provided cornerpoint0: "; if (mitk::Equal(geometry->GetCornerPoint(0), cornerpoint0) == false) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Creating and initializing a SliceNavigationController with the Geometry3D: "; mitk::SliceNavigationController::Pointer sliceCtrl = mitk::SliceNavigationController::New(); sliceCtrl->SetInputWorldGeometry3D(geometry); std::cout << "[PASSED]" << std::endl; std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Axial): "; sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial); std::cout << "[PASSED]" << std::endl; std::cout << "Testing Update(): "; sliceCtrl->Update(); std::cout << "[PASSED]" << std::endl; std::cout << "Testing result of CreatedWorldGeometry(): "; mitk::Point3D axialcornerpoint0; axialcornerpoint0 = cornerpoint0 + bottom + normal * (numSlices - 1 + 0.5); // really -1? result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, height, numSlices, widthInMM, heightInMM, thicknessInMM * numSlices, axialcornerpoint0, right, bottom * (-1.0), normal * (-1.0)); if (result != EXIT_SUCCESS) { std::cout << "[FAILED]" << std::endl; return result; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Frontal): "; sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Frontal); std::cout << "[PASSED]" << std::endl; std::cout << "Testing Update(): "; sliceCtrl->Update(); std::cout << "[PASSED]" << std::endl; std::cout << "Testing result of CreatedWorldGeometry(): "; mitk::Point3D frontalcornerpoint0; frontalcornerpoint0 = cornerpoint0 + geometry->GetAxisVector(1) * (+0.5 / geometry->GetExtent(1)); result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, numSlices, height, widthInMM, thicknessInMM * numSlices, heightInMM, frontalcornerpoint0, right, normal, bottom); if (result != EXIT_SUCCESS) { std::cout << "[FAILED]" << std::endl; return result; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Sagittal): "; sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Sagittal); std::cout << "[PASSED]" << std::endl; std::cout << "Testing Update(): " << std::endl; sliceCtrl->Update(); std::cout << "[PASSED]" << std::endl; std::cout << "Testing result of CreatedWorldGeometry(): "; mitk::Point3D sagittalcornerpoint0; sagittalcornerpoint0 = cornerpoint0 + geometry->GetAxisVector(0) * (+0.5 / geometry->GetExtent(0)); result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), height, numSlices, width, heightInMM, thicknessInMM * numSlices, widthInMM, sagittalcornerpoint0, bottom, normal, right); if (result != EXIT_SUCCESS) { std::cout << "[FAILED]" << std::endl; return result; } std::cout << "[PASSED]" << std::endl; return EXIT_SUCCESS; } int testReorientPlanes() { // Create PlaneGeometry mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New(); mitk::Point3D origin; mitk::Vector3D right, bottom, normal; mitk::ScalarType width, height; mitk::ScalarType widthInMM, heightInMM, thicknessInMM; width = 100; widthInMM = width; height = 200; heightInMM = height; thicknessInMM = 1.5; mitk::FillVector3D(origin, 4.5, 7.3, 11.2); mitk::FillVector3D(right, widthInMM, 0, 0); mitk::FillVector3D(bottom, 0, heightInMM, 0); mitk::FillVector3D(normal, 0, 0, thicknessInMM); mitk::Vector3D spacing; normal.Normalize(); normal *= thicknessInMM; mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM); planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing); planegeometry->SetOrigin(origin); // Create SlicedGeometry3D out of planeGeometry mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New(); unsigned int numSlices = 20; - slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false); + slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices); // Create another slicedgeo which will be rotated mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New(); - slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false); + slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices); // Create geo3D as reference mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New(); geometry->SetBounds(slicedgeometry1->GetBounds()); geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform()); // Initialize planes for (int i = 0; i < (int)numSlices; i++) { mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New(); geo2d->Initialize(); geo2d->SetReferenceGeometry(geometry); slicedgeometry1->SetPlaneGeometry(geo2d, i); } for (int i = 0; i < (int)numSlices; i++) { mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New(); geo2d->Initialize(); geo2d->SetReferenceGeometry(geometry); slicedgeometry2->SetPlaneGeometry(geo2d, i); } slicedgeometry1->SetReferenceGeometry(geometry); slicedgeometry2->SetReferenceGeometry(geometry); // Create SNC mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New(); sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1); sliceCtrl1->Update(); mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New(); sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2); sliceCtrl2->Update(); slicedgeometry1->SetSliceNavigationController(sliceCtrl1); slicedgeometry2->SetSliceNavigationController(sliceCtrl2); // Whats current geometry? MITK_INFO << "center: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter(); MITK_INFO << "normal: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal(); MITK_INFO << "origin: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin(); MITK_INFO << "axis0 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0); MITK_INFO << "aixs1 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1); // // Now reorient slices (ONE POINT, ONE NORMAL) mitk::Point3D oldCenter, oldOrigin; mitk::Vector3D oldAxis0, oldAxis1; oldCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter(); oldOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin(); oldAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0); oldAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1); mitk::Point3D orientCenter; mitk::Vector3D orientNormal; orientCenter = oldCenter; mitk::FillVector3D(orientNormal, 0.3, 0.1, 0.8); orientNormal.Normalize(); sliceCtrl1->ReorientSlices(orientCenter, orientNormal); mitk::Point3D newCenter, newOrigin; mitk::Vector3D newNormal; newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter(); newOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin(); newNormal = sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal(); newNormal.Normalize(); itk::Index<3> orientCenterIdx; itk::Index<3> newCenterIdx; sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx); sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx); if ((newCenterIdx != orientCenterIdx) || (!mitk::Equal(orientNormal, newNormal))) { MITK_INFO << "Reorient Planes (1 point, 1 vector) not working as it should"; MITK_INFO << "orientCenterIdx: " << orientCenterIdx; MITK_INFO << "newCenterIdx: " << newCenterIdx; MITK_INFO << "orientNormal: " << orientNormal; MITK_INFO << "newNormal: " << newNormal; return EXIT_FAILURE; } // // Now reorient slices (center, vec0, vec1 ) mitk::Vector3D orientAxis0, orientAxis1, newAxis0, newAxis1; mitk::FillVector3D(orientAxis0, 1.0, 0.0, 0.0); mitk::FillVector3D(orientAxis1, 0.0, 1.0, 0.0); orientAxis0.Normalize(); orientAxis1.Normalize(); sliceCtrl1->ReorientSlices(orientCenter, orientAxis0, orientAxis1); newAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0); newAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1); newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter(); newAxis0.Normalize(); newAxis1.Normalize(); sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx); sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx); if ((newCenterIdx != orientCenterIdx) || (!mitk::Equal(orientAxis0, newAxis0, 1E-12)) || (!mitk::Equal(orientAxis1, newAxis1, 1E-12))) { MITK_INFO << "Reorient Planes (point, vec, vec) not working as it should"; MITK_INFO << "orientCenterIdx: " << orientCenterIdx; MITK_INFO << "newCenterIdx: " << newCenterIdx; MITK_INFO << "orientAxis0: " << orientAxis0; MITK_INFO << "newAxis0: " << newAxis0; MITK_INFO << "orientAxis1: " << orientAxis1; MITK_INFO << "newAxis1: " << newAxis1; return EXIT_FAILURE; } return EXIT_SUCCESS; } int testRestorePlanePostionOperation() { // Create PlaneGeometry mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New(); mitk::Point3D origin; mitk::Vector3D right, bottom, normal; mitk::ScalarType width, height; mitk::ScalarType widthInMM, heightInMM, thicknessInMM; width = 100; widthInMM = width; height = 200; heightInMM = height; thicknessInMM = 1.5; mitk::FillVector3D(origin, 4.5, 7.3, 11.2); mitk::FillVector3D(right, widthInMM, 0, 0); mitk::FillVector3D(bottom, 0, heightInMM, 0); mitk::FillVector3D(normal, 0, 0, thicknessInMM); mitk::Vector3D spacing; normal.Normalize(); normal *= thicknessInMM; mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM); planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing); planegeometry->SetOrigin(origin); // Create SlicedGeometry3D out of planeGeometry mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New(); unsigned int numSlices = 300; - slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false); + slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices); // Create another slicedgeo which will be rotated mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New(); - slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false); + slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices); // Create geo3D as reference mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New(); geometry->SetBounds(slicedgeometry1->GetBounds()); geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform()); // Initialize planes for (int i = 0; i < (int)numSlices; i++) { mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New(); geo2d->Initialize(); geo2d->SetReferenceGeometry(geometry); slicedgeometry1->SetPlaneGeometry(geo2d, i); } for (int i = 0; i < (int)numSlices; i++) { mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New(); geo2d->Initialize(); geo2d->SetReferenceGeometry(geometry); slicedgeometry2->SetPlaneGeometry(geo2d, i); } slicedgeometry1->SetReferenceGeometry(geometry); slicedgeometry2->SetReferenceGeometry(geometry); // Create SNC mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New(); sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1); sliceCtrl1->Update(); mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New(); sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2); sliceCtrl2->Update(); slicedgeometry1->SetSliceNavigationController(sliceCtrl1); slicedgeometry2->SetSliceNavigationController(sliceCtrl2); // Rotate slicedgeo2 double angle = 63.84; mitk::Vector3D rotationVector; mitk::FillVector3D(rotationVector, 0.5, 0.95, 0.23); mitk::Point3D center = slicedgeometry2->GetCenter(); mitk::RotationOperation *op = new mitk::RotationOperation(mitk::OpROTATE, center, rotationVector, angle); slicedgeometry2->ExecuteOperation(op); sliceCtrl2->Update(); us::ServiceReference serviceRef = us::GetModuleContext()->GetServiceReference(); mitk::PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef); service->AddNewPlanePosition(slicedgeometry2->GetPlaneGeometry(0), 178); sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0)); sliceCtrl1->Update(); mitk::PlaneGeometry *planeRotated = slicedgeometry2->GetPlaneGeometry(178); mitk::PlaneGeometry *planeRestored = dynamic_cast(sliceCtrl1->GetCurrentGeometry3D())->GetPlaneGeometry(178); try { MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(planeRotated->GetIndexToWorldTransform()->GetMatrix(), planeRestored->GetIndexToWorldTransform()->GetMatrix()), "Testing for IndexToWorld"); MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetOrigin(), planeRestored->GetOrigin(), 2 * mitk::eps), "Testing for origin"); MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetSpacing(), planeRestored->GetSpacing()), "Testing for spacing"); MITK_TEST_CONDITION_REQUIRED( mitk::Equal( slicedgeometry2->GetDirectionVector(), dynamic_cast(sliceCtrl1->GetCurrentGeometry3D())->GetDirectionVector()), "Testing for directionvector"); MITK_TEST_CONDITION_REQUIRED( mitk::Equal(slicedgeometry2->GetSlices(), dynamic_cast(sliceCtrl1->GetCurrentGeometry3D())->GetSlices()), "Testing for numslices"); MITK_TEST_CONDITION_REQUIRED( mitk::MatrixEqualElementWise(slicedgeometry2->GetIndexToWorldTransform()->GetMatrix(), dynamic_cast(sliceCtrl1->GetCurrentGeometry3D()) ->GetIndexToWorldTransform() ->GetMatrix()), "Testing for IndexToWorld"); } catch (...) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int mitkSliceNavigationControllerTest(int /*argc*/, char * /*argv*/ []) { int result = EXIT_FAILURE; std::cout << "Creating and initializing a PlaneGeometry: "; mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New(); mitk::Point3D origin; mitk::Vector3D right, bottom, normal; mitk::ScalarType width, height; mitk::ScalarType widthInMM, heightInMM, thicknessInMM; width = 100; widthInMM = width; height = 200; heightInMM = height; thicknessInMM = 1.5; // mitk::FillVector3D(origin, 0, 0, thicknessInMM*0.5); mitk::FillVector3D(origin, 4.5, 7.3, 11.2); mitk::FillVector3D(right, widthInMM, 0, 0); mitk::FillVector3D(bottom, 0, heightInMM, 0); mitk::FillVector3D(normal, 0, 0, thicknessInMM); mitk::Vector3D spacing; normal.Normalize(); normal *= thicknessInMM; mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM); planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing); planegeometry->SetOrigin(origin); std::cout << "[PASSED]" << std::endl; std::cout << "Creating and initializing a SlicedGeometry3D with the PlaneGeometry: "; mitk::SlicedGeometry3D::Pointer slicedgeometry = mitk::SlicedGeometry3D::New(); unsigned int numSlices = 5; - slicedgeometry->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false); + slicedgeometry->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices); std::cout << "[PASSED]" << std::endl; std::cout << "Creating a Geometry3D with the same extent as the SlicedGeometry3D: "; mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New(); geometry->SetBounds(slicedgeometry->GetBounds()); geometry->SetIndexToWorldTransform(slicedgeometry->GetIndexToWorldTransform()); std::cout << "[PASSED]" << std::endl; mitk::Point3D cornerpoint0; cornerpoint0 = geometry->GetCornerPoint(0); result = testGeometry( geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal); if (result != EXIT_SUCCESS) return result; mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New(); transform->SetMatrix(geometry->GetIndexToWorldTransform()->GetMatrix()); mitk::BoundingBox::Pointer boundingbox = geometry->CalculateBoundingBoxRelativeToTransform(transform); geometry->SetBounds(boundingbox->GetBounds()); cornerpoint0 = geometry->GetCornerPoint(0); result = testGeometry( geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal); if (result != EXIT_SUCCESS) return result; std::cout << "Changing the IndexToWorldTransform of the geometry to a rotated version by SetIndexToWorldTransform() " "(keep cornerpoint0): "; transform = mitk::AffineTransform3D::New(); mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix; vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix(); mitk::VnlVector axis(3); mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize(); vnl_quaternion rotation(axis, 0.223); vnlmatrix = rotation.rotation_matrix_transpose() * vnlmatrix; mitk::Matrix3D matrix; matrix = vnlmatrix; transform->SetMatrix(matrix); transform->SetOffset(cornerpoint0.GetVectorFromOrigin()); right.SetVnlVector(rotation.rotation_matrix_transpose() * right.GetVnlVector()); bottom.SetVnlVector(rotation.rotation_matrix_transpose() * bottom.GetVnlVector()); normal.SetVnlVector(rotation.rotation_matrix_transpose() * normal.GetVnlVector()); geometry->SetIndexToWorldTransform(transform); std::cout << "[PASSED]" << std::endl; cornerpoint0 = geometry->GetCornerPoint(0); result = testGeometry( geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal); if (result != EXIT_SUCCESS) return result; // Testing Execute RestorePlanePositionOperation result = testRestorePlanePostionOperation(); if (result != EXIT_SUCCESS) return result; // Re-Orient planes not working as it should on windows // However, this might be adjusted during a geometry redesign. /* //Testing ReorientPlanes result = testReorientPlanes(); if(result!=EXIT_SUCCESS) return result; */ std::cout << "[TEST DONE]" << std::endl; return EXIT_SUCCESS; } \ No newline at end of file diff --git a/Modules/Core/test/mitkSlicedGeometry3DTest.cpp b/Modules/Core/test/mitkSlicedGeometry3DTest.cpp index b0fd527a4b..1d75ab6131 100644 --- a/Modules/Core/test/mitkSlicedGeometry3DTest.cpp +++ b/Modules/Core/test/mitkSlicedGeometry3DTest.cpp @@ -1,288 +1,288 @@ /*=================================================================== 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 "mitkImage.h" #include "mitkPlaneGeometry.h" #include "mitkSlicedGeometry3D.h" #include "mitkTestingMacros.h" #include #include #include static const mitk::ScalarType slicedGeometryEps = 1E-9; // epsilon for this testfile. Set to float precision. void mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test() { // Tests for Offset MITK_TEST_OUTPUT(<< "====== NOW RUNNING: Tests for pixel-center-based offset concerns ========"); // create a SlicedGeometry3D mitk::SlicedGeometry3D::Pointer slicedGeo3D = mitk::SlicedGeometry3D::New(); int num_slices = 5; slicedGeo3D->InitializeSlicedGeometry(num_slices); // 5 slices mitk::Point3D newOrigin; newOrigin[0] = 91.3; newOrigin[1] = -13.3; newOrigin[2] = 0; slicedGeo3D->SetOrigin(newOrigin); mitk::Vector3D newSpacing; newSpacing[0] = 1.0f; newSpacing[1] = 0.9f; newSpacing[2] = 0.3f; slicedGeo3D->SetSpacing(newSpacing); // create subslices as well for (int i = 0; i < num_slices; i++) { mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New(); geo2d->Initialize(); slicedGeo3D->SetPlaneGeometry(geo2d, i); } // now run tests MITK_TEST_OUTPUT(<< "Testing whether slicedGeo3D->GetImageGeometry() is false by default"); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetImageGeometry() == false, ""); MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false by default"); mitk::BaseGeometry *subSliceGeo2D_first = slicedGeo3D->GetPlaneGeometry(0); mitk::BaseGeometry *subSliceGeo2D_last = slicedGeo3D->GetPlaneGeometry(num_slices - 1); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetImageGeometry() == false, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetImageGeometry() == false, ""); // Save some Origins and cornerpoints mitk::Point3D OriginSlicedGeo(slicedGeo3D->GetOrigin()); mitk::Point3D OriginFirstGeo(subSliceGeo2D_first->GetOrigin()); mitk::Point3D OriginLastGeo(subSliceGeo2D_last->GetOrigin()); mitk::Point3D CornerPoint0SlicedGeo(slicedGeo3D->GetCornerPoint(0)); mitk::Point3D CornerPoint1FirstGeo(subSliceGeo2D_first->GetCornerPoint(1)); mitk::Point3D CornerPoint2LastGeo(subSliceGeo2D_last->GetCornerPoint(2)); MITK_TEST_OUTPUT(<< "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true)"); // std::cout << "vorher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl; // std::cout << "vorher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl; slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true); // std::cout << "nachher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl; // std::cout << "nachher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl; MITK_TEST_OUTPUT(<< "Testing whether slicedGeo3D->GetImageGeometry() is now true"); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetImageGeometry() == true, ""); MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==true now"); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetImageGeometry() == true, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetImageGeometry() == true, ""); MITK_TEST_OUTPUT(<< "Testing wether offset has been added to origins"); // Manually adding Offset. OriginSlicedGeo[0] += (slicedGeo3D->GetSpacing()[0]) / 2; OriginSlicedGeo[1] += (slicedGeo3D->GetSpacing()[1]) / 2; OriginSlicedGeo[2] += (slicedGeo3D->GetSpacing()[2]) / 2; OriginFirstGeo[0] += (subSliceGeo2D_first->GetSpacing()[0]) / 2; OriginFirstGeo[1] += (subSliceGeo2D_first->GetSpacing()[1]) / 2; OriginFirstGeo[2] += (subSliceGeo2D_first->GetSpacing()[2]) / 2; OriginLastGeo[0] += (subSliceGeo2D_last->GetSpacing()[0]) / 2; OriginLastGeo[1] += (subSliceGeo2D_last->GetSpacing()[1]) / 2; OriginLastGeo[2] += (subSliceGeo2D_last->GetSpacing()[2]) / 2; MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetCornerPoint(1) == CornerPoint1FirstGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetCornerPoint(2) == CornerPoint2LastGeo, ""); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetCornerPoint(0) == CornerPoint0SlicedGeo, ""); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetOrigin() == OriginSlicedGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetOrigin() == OriginFirstGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetOrigin() == OriginLastGeo, ""); MITK_TEST_OUTPUT(<< "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false)"); slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false); MITK_TEST_OUTPUT(<< "Testing whether slicedGeo3D->GetImageGeometry() is now false"); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetImageGeometry() == false, ""); MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false now"); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetImageGeometry() == false, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetImageGeometry() == false, ""); MITK_TEST_OUTPUT(<< "Testing wether offset has been added to origins of geometry"); // Manually substracting Offset. OriginSlicedGeo[0] -= (slicedGeo3D->GetSpacing()[0]) / 2; OriginSlicedGeo[1] -= (slicedGeo3D->GetSpacing()[1]) / 2; OriginSlicedGeo[2] -= (slicedGeo3D->GetSpacing()[2]) / 2; OriginFirstGeo[0] -= (subSliceGeo2D_first->GetSpacing()[0]) / 2; OriginFirstGeo[1] -= (subSliceGeo2D_first->GetSpacing()[1]) / 2; OriginFirstGeo[2] -= (subSliceGeo2D_first->GetSpacing()[2]) / 2; OriginLastGeo[0] -= (subSliceGeo2D_last->GetSpacing()[0]) / 2; OriginLastGeo[1] -= (subSliceGeo2D_last->GetSpacing()[1]) / 2; OriginLastGeo[2] -= (subSliceGeo2D_last->GetSpacing()[2]) / 2; MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetCornerPoint(1) == CornerPoint1FirstGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetCornerPoint(2) == CornerPoint2LastGeo, ""); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetCornerPoint(0) == CornerPoint0SlicedGeo, ""); MITK_TEST_CONDITION_REQUIRED(slicedGeo3D->GetOrigin() == OriginSlicedGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_first->GetOrigin() == OriginFirstGeo, ""); MITK_TEST_CONDITION_REQUIRED(subSliceGeo2D_last->GetOrigin() == OriginLastGeo, ""); MITK_TEST_OUTPUT(<< "ALL SUCCESSFULLY!"); } int mitkSlicedGeometry3DTest(int /*argc*/, char * /*argv*/ []) { mitk::PlaneGeometry::Pointer planegeometry1 = mitk::PlaneGeometry::New(); mitk::Point3D origin; mitk::Vector3D right, bottom, normal; mitk::ScalarType width, height; mitk::ScalarType widthInMM, heightInMM, thicknessInMM; width = 100; widthInMM = width; height = 200; heightInMM = height; thicknessInMM = 3.5; mitk::FillVector3D(origin, 4.5, 7.3, 11.2); mitk::FillVector3D(right, widthInMM, 0, 0); mitk::FillVector3D(bottom, 0, heightInMM, 0); mitk::FillVector3D(normal, 0, 0, thicknessInMM); std::cout << "Initializing planegeometry1 by InitializeStandardPlane(rightVector, downVector, spacing = NULL): " << std::endl; planegeometry1->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector()); std::cout << "Setting planegeometry2 to a cloned version of planegeometry1: " << std::endl; mitk::PlaneGeometry::Pointer planegeometry2; planegeometry2 = dynamic_cast(planegeometry1->Clone().GetPointer()); ; std::cout << "Changing the IndexToWorldTransform of planegeometry2 to a rotated version by " "SetIndexToWorldTransform() (keep origin): " << std::endl; mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New(); mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix; vnlmatrix = planegeometry2->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix(); mitk::VnlVector axis(3); mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize(); vnl_quaternion rotation(axis, 0.123); vnlmatrix = rotation.rotation_matrix_transpose() * vnlmatrix; mitk::Matrix3D matrix; matrix = vnlmatrix; transform->SetMatrix(matrix); transform->SetOffset(planegeometry2->GetIndexToWorldTransform()->GetOffset()); right.SetVnlVector(rotation.rotation_matrix_transpose() * right.GetVnlVector()); bottom.SetVnlVector(rotation.rotation_matrix_transpose() * bottom.GetVnlVector()); normal.SetVnlVector(rotation.rotation_matrix_transpose() * normal.GetVnlVector()); planegeometry2->SetIndexToWorldTransform(transform); std::cout << "Setting planegeometry3 to the backside of planegeometry2: " << std::endl; mitk::PlaneGeometry::Pointer planegeometry3 = mitk::PlaneGeometry::New(); planegeometry3->InitializeStandardPlane(planegeometry2, mitk::PlaneGeometry::Axial, 0, false); std::cout - << "Testing SlicedGeometry3D::InitializeEvenlySpaced(planegeometry3, zSpacing = 1, slices = 5, flipped = false): " + << "Testing SlicedGeometry3D::InitializeEvenlySpaced(planegeometry3, zSpacing = 1, slices = 5): " << std::endl; mitk::SlicedGeometry3D::Pointer slicedWorldGeometry = mitk::SlicedGeometry3D::New(); unsigned int numSlices = 5; - slicedWorldGeometry->InitializeEvenlySpaced(planegeometry3, 1, numSlices, false); + slicedWorldGeometry->InitializeEvenlySpaced(planegeometry3, 1, numSlices); std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: "; mitk::PlaneGeometry *accessedplanegeometry3 = dynamic_cast(slicedWorldGeometry->GetPlaneGeometry(0)); if (accessedplanegeometry3 == nullptr) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing whether the first geometry in the SlicedGeometry3D is identical to planegeometry3 by axis " "comparison and origin: " << std::endl; if ((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin(), slicedGeometryEps) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing availability and type (PlaneGeometry) of the last geometry in the SlicedGeometry3D: "; mitk::PlaneGeometry *accessedplanegeometry3last = dynamic_cast(slicedWorldGeometry->GetPlaneGeometry(numSlices - 1)); mitk::Point3D origin3last; origin3last = planegeometry3->GetOrigin() + slicedWorldGeometry->GetDirectionVector() * (numSlices - 1); if (accessedplanegeometry3last == nullptr) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Testing whether the last geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison: " << std::endl; if ((mitk::Equal(accessedplanegeometry3last->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3last->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3last->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3last->GetOrigin(), origin3last, slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3last->GetIndexToWorldTransform()->GetOffset(), origin3last.GetVectorFromOrigin(), slicedGeometryEps) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Again for first slice - Testing availability and type (PlaneGeometry) of first geometry in the " "SlicedGeometry3D: "; accessedplanegeometry3 = dynamic_cast(slicedWorldGeometry->GetPlaneGeometry(0)); if (accessedplanegeometry3 == nullptr) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; std::cout << "Again for first slice - Testing whether the first geometry in the SlicedGeometry3D is identical to " "planegeometry3 by axis comparison and origin: " << std::endl; if ((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin(), slicedGeometryEps) == false) || (mitk::Equal(accessedplanegeometry3->GetIndexToWorldTransform()->GetOffset(), planegeometry3->GetOrigin().GetVectorFromOrigin(), slicedGeometryEps) == false)) { std::cout << "[FAILED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test(); std::cout << "[TEST DONE]" << std::endl; return EXIT_SUCCESS; }