diff --git a/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp index 46b02bf660..5022b907de 100644 --- a/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp +++ b/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp @@ -1,418 +1,418 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-15 11:12:36 +0100 (Mo, 15 Mrz 2010) $ Version: $Revision: 21745 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkTestingMacros.h" #include "mitkPlanarCross.h" #include "mitkPlaneGeometry.h" class mitkPlanarCrossTestClass { public: static void TestPlanarCrossPlacement( mitk::PlanarCross::Pointer planarCross ) { // Test for correct minimum number of control points in cross-mode MITK_TEST_CONDITION( planarCross->GetMinimumNumberOfControlPoints() == 4, "Minimum number of control points" ); // Test for correct maximum number of control points in cross-mode MITK_TEST_CONDITION( planarCross->GetMaximumNumberOfControlPoints() == 4, "Maximum number of control points" ); // Initial placement of PlanarCross mitk::Point2D p0; p0[0] = 20.0; p0[1] = 20.0; planarCross->PlaceFigure( p0 ); // Add second control point mitk::Point2D p1; p1[0] = 80.0; p1[1] = 80.0; planarCross->SetCurrentControlPoint( p1 ); // Add third control point mitk::Point2D p2; p2[0] = 90.0; p2[1] = 10.0; planarCross->AddControlPoint( p2 ); // Test if helper polyline is generated const mitk::PlanarFigure::PolyLineType helperPolyLine = planarCross->GetHelperPolyLine( 0, 1.0, 100 ); MITK_TEST_CONDITION( planarCross->GetHelperPolyLinesSize() == 1, "Number of helper polylines after placing 3 points" ); // Test if helper polyline is marked as "to be painted" MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ), "Helper line to be painted after placing 3 points" ); // Test if helper polyline is orthogonal to first line mitk::Vector2D v0 = p1 - p0; v0.Normalize(); // TODO: make it work again //mitk::Vector2D hv = helperPolyLine->ElementAt( 1 ) - helperPolyLine->ElementAt( 0 ); //hv.Normalize(); //MITK_TEST_CONDITION( fabs(v0 * hv) < mitk::eps, "Helper line is orthogonal to first line" ); //// Test if helper polyline is placed correctly //mitk::Vector2D hv1 = helperPolyLine->ElementAt( 1 ) - p2; //hv1.Normalize(); //MITK_TEST_CONDITION( fabs(hv * hv1 - 1.0) < mitk::eps, "Helper line is aligned to third point" ); // Add fourth control point mitk::Point2D p3; p3[0] = 10.0; p3[1] = 90.0; planarCross->AddControlPoint( p3 ); // Test for number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 4, "Number of control points after placement" ); // Test if PlanarFigure is closed MITK_TEST_CONDITION( !planarCross->IsClosed(), "Is PlanarFigure closed?" ); // Test if helper polyline is no longer marked as "to be painted" MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ), "Helper line no longer to be painted after placement of all 4 points" ); // Test for number of polylines const mitk::PlanarFigure::PolyLineType polyLine0 = planarCross->GetPolyLine( 0 ); const mitk::PlanarFigure::PolyLineType polyLine1 = planarCross->GetPolyLine( 1 ); MITK_TEST_CONDITION( planarCross->GetPolyLinesSize() == 2, "Number of polylines after placement" ); mitk::PlanarFigure::PolyLineType::const_iterator iter0 = polyLine0.begin(); mitk::PlanarFigure::PolyLineType::const_iterator iter1 = polyLine1.begin(); // Get polylines and check if the generated coordinates are OK const mitk::Point2D& pp0 = iter0->Point; iter0++; const mitk::Point2D& pp1 = iter0->Point; MITK_TEST_CONDITION( ((pp0 == p0) && (pp1 == p1)) || ((pp0 == p1) && (pp1 == p0)), "Correct polyline 1" ); const mitk::Point2D& pp2 = iter1->Point; iter1++; const mitk::Point2D& pp3 = iter1->Point; MITK_TEST_CONDITION( ((pp2 == p2) && (pp3 == p3)) || ((pp2 == p3) && (pp3 == p2)), "Correct polyline 2" ); // Test for number of measurement features planarCross->EvaluateFeatures(); MITK_TEST_CONDITION( planarCross->GetNumberOfFeatures() == 2, "Number of measurement features" ); // Test for correct feature evaluation double length0 = sqrt( 80.0 * 80.0 * 2.0 ); MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 0 ) - length0) < mitk::eps, "Size of longest diameter" ); double length1 = sqrt( 60.0 * 60.0 * 2.0 ); MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 1 ) - length1) < mitk::eps, "Size of short axis diameter" ); } static void TestPlanarCrossPlacementSingleLine(mitk::PlanarCross::Pointer planarCross) { // Test for correct minimum number of control points in cross-mode MITK_TEST_CONDITION( planarCross->GetMinimumNumberOfControlPoints() == 2, "Minimum number of control points" ); // Test for correct maximum number of control points in cross-mode MITK_TEST_CONDITION( planarCross->GetMaximumNumberOfControlPoints() == 2, "Maximum number of control points" ); // Initial placement of PlanarCross mitk::Point2D p0; p0[0] = 25.0; p0[1] = 10.0; planarCross->PlaceFigure( p0 ); // Add second control point mitk::Point2D p1; p1[0] = 30.0; p1[1] = 60.0; planarCross->SetCurrentControlPoint( p1 ); // Verify that no helper line is drawn MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ) == false, "No helper line to be painted in single-line mode" ); // Test for number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Number of control points after placement" ); // Test if PlanarFigure is closed MITK_TEST_CONDITION( !planarCross->IsClosed(), "Is PlanarFigure closed?" ); // Test for number of polylines const mitk::PlanarFigure::PolyLineType polyLine0 = planarCross->GetPolyLine( 0 ); - const mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin(); + mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin(); MITK_TEST_CONDITION( planarCross->GetPolyLinesSize() == 1, "Number of polylines after placement" ); // Get polylines and check if the generated coordinates are OK const mitk::Point2D& pp0 = iter->Point; iter++; const mitk::Point2D& pp1 = iter->Point; MITK_TEST_CONDITION( ((pp0 == p0) && (pp1 == p1)) || ((pp0 == p1) && (pp1 == p0)), "Correct polyline 1" ); // Test for number of measurement features planarCross->EvaluateFeatures(); MITK_TEST_CONDITION( planarCross->GetNumberOfFeatures() == 1, "Number of measurement features" ); // Test for correct feature evaluation double length0 = sqrt( 5.0 * 5.0 + 50.0 * 50.0 ); MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 0 ) - length0) < mitk::eps, "Size of diameter" ); // Test if reset called on single-line PlanarCross returns false (nothing to reset) MITK_TEST_CONDITION( planarCross->ResetOnPointSelect() == false, "Single-line PlanarCross should not be reset on point edit" ); } static void TestPlanarCrossPlacementConstrained(mitk::PlanarCross::Pointer planarCross) { // ************************************************************************** // Place first control point out of bounds (to the left of the image bounds) mitk::Point2D p0; p0[0] = -20.0; p0[1] = 20.0; planarCross->PlaceFigure( p0 ); // Test if constraint has been applied correctly mitk::Point2D cp0 = planarCross->GetControlPoint( 0 ); MITK_TEST_CONDITION( (fabs(cp0[0]) < mitk::eps) && (fabs(cp0[1] - 20.0) < mitk::eps), "Point1 placed and constrained correctly" ); // ************************************************************************** // Add second control point out of bounds (to the top of the image bounds) mitk::Point2D p1; p1[0] = 80.0; p1[1] = 120.0; planarCross->SetCurrentControlPoint( p1 ); // Test if constraint has been applied correctly mitk::Point2D cp1 = planarCross->GetControlPoint( 1 ); MITK_TEST_CONDITION( (fabs(cp1[0] - 80.0) < mitk::eps) && (fabs(cp1[1] - 100.0) < mitk::eps), "Point2 placed and constrained correctly" ); // ************************************************************************** // Add third control point out of bounds (outside of channel defined by first line) mitk::Point2D p2; p2[0] = 100.0; p2[1] = 100.0; planarCross->AddControlPoint( p2 ); // Test if constraint has been applied correctly (100.0, 100.0) must be projected to (90.0, 90.0) mitk::Point2D cp2 = planarCross->GetControlPoint( 2 ); MITK_TEST_CONDITION( (fabs(cp2[0] - 90.0) < mitk::eps) && (fabs(cp2[1] - 90.0) < mitk::eps), "Point3 placed and constrained correctly" ); // Move third control point (within channel defined by first line) p2[0] = 40.0; p2[1] = 20.0; planarCross->SetControlPoint( 2, p2 ); // Test if point is still at this position (no constrained should be applied) cp2 = planarCross->GetControlPoint( 2 ); MITK_TEST_CONDITION( (fabs(cp2[0] - 40.0) < mitk::eps) && (fabs(cp2[1] - 20.0) < mitk::eps), "Point3 moved correctly" ); // ************************************************************************** // Add fourth control point out of bounds (outside of line defined by first line and third point) mitk::Point2D p3; p3[0] = 20.0; p3[1] = 60.0; planarCross->AddControlPoint( p3 ); // Test if constraint has been applied correctly (20.0, 60.0) must be projected to (10.0, 50.0) mitk::Point2D cp3 = planarCross->GetControlPoint( 3 ); MITK_TEST_CONDITION( (fabs(cp3[0] - 10.0) < mitk::eps) && (fabs(cp3[1] - 50.0) < mitk::eps), "Point4 placed and constrained correctly" ); // Move fourth control point (to a position which would result in two non-intersecting line // without the constraint that lines have to intersect) p3[0] = 40.0; p3[1] = 30.0; planarCross->SetControlPoint( 3, p3 ); // Test if constrained point is on the projected intersection point of both lines (20.0/40.0) cp3 = planarCross->GetControlPoint( 3 ); MITK_TEST_CONDITION( (fabs(cp3[0] - 20.0) < mitk::eps) && (fabs(cp3[1] - 40.0) < mitk::eps), "Point4 placed and constrained correctly" ); } static void TestPlanarCrossEdit(mitk::PlanarCross::Pointer planarCross) { // * point move (different points) // --> reset // --> test which point is where / evaluation mitk::Point2D p0 = planarCross->GetControlPoint( 0 ); mitk::Point2D p1 = planarCross->GetControlPoint( 1 ); mitk::Point2D p2 = planarCross->GetControlPoint( 2 ); mitk::Point2D p3 = planarCross->GetControlPoint( 3 ); // ************************************************************************** // Edit control point 0 planarCross->SelectControlPoint( 0 ); // Request reset and check if it is done MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 0: Double-line PlanarCross should be reset" ); // Check number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" ); // Check if correct control points have been left MITK_TEST_CONDITION( (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p1 ) < mitk::eps) && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p0 ) < mitk::eps), "Reset to expected control points (p1, p0)" ); // Reset planar cross to original values ResetPlanarCross( planarCross, p0, p1, p2, p3 ); // ************************************************************************** // Edit control point 1 planarCross->SelectControlPoint( 1 ); // Request reset and check if it is done MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 1: Double-line PlanarCross should be reset" ); // Check number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" ); // Check if correct control points have been left MITK_TEST_CONDITION( (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p0 ) < mitk::eps) && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p1 ) < mitk::eps), "Reset to expected control points (p0, p1)" ); // Reset planar cross to original values ResetPlanarCross( planarCross, p0, p1, p2, p3 ); // ************************************************************************** // Edit control point 2 planarCross->SelectControlPoint( 2 ); // Request reset and check if it is done MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 2: Double-line PlanarCross should be reset" ); // Check number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" ); // Check if correct control points have been left MITK_TEST_CONDITION( (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p3 ) < mitk::eps) && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p2 ) < mitk::eps), "Reset to expected control points (p3, p2)" ); // Reset planar cross to original values ResetPlanarCross( planarCross, p0, p1, p2, p3 ); // ************************************************************************** // Edit control point 3 planarCross->SelectControlPoint( 3 ); // Request reset and check if it is done MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 3: Double-line PlanarCross should be reset" ); // Check number of control points MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" ); // Check if correct control points have been left MITK_TEST_CONDITION( (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p2 ) < mitk::eps) && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p3 ) < mitk::eps), "Reset to expected control points (p2, p3)" ); } static void ResetPlanarCross( mitk::PlanarCross::Pointer planarCross, mitk::Point2D p0, mitk::Point2D p1, mitk::Point2D p2, mitk::Point2D p3 ) { planarCross->SetControlPoint( 0, p0, true ); planarCross->SetControlPoint( 1, p1, true ); planarCross->SetControlPoint( 2, p2, true ); planarCross->SetControlPoint( 3, p3, true ); } }; /** * mitkPlanarCrossTest tests the methods and behavior of mitk::PlanarCross with four sub-tests: * * 1. Double-line mode instantiation and basic tests * 2. Single-line mode instantiation and basic tests * 3. Tests of application of spatial constraints for double-line mode * 4. Tests if editing of PlanarCross works as intended * */ int mitkPlanarCrossTest(int /* argc */, char* /*argv*/[]) { // always start with this! MITK_TEST_BEGIN("PlanarCross") // create PlaneGeometry on which to place the PlanarCross mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New(); planeGeometry->InitializeStandardPlane( 100.0, 100.0 ); // ************************************************************************** // 1. Double-line mode instantiation and basic tests mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New(); planarCross->SetGeometry2D( planeGeometry ); // first test: did this work? MITK_TEST_CONDITION_REQUIRED( planarCross.IsNotNull(), "Testing instantiation" ); // test: default cross-mode (not single-line-mode)? MITK_TEST_CONDITION_REQUIRED( !planarCross->GetSingleLineMode(), "Testing default cross mode" ); // Test placement of PlanarCross by control points mitkPlanarCrossTestClass::TestPlanarCrossPlacement( planarCross ); // ************************************************************************** // 2. Single-line mode instantiation and basic tests planarCross = mitk::PlanarCross::New(); planarCross->SingleLineModeOn(); planarCross->SetGeometry2D( planeGeometry ); // test: single-line mode? MITK_TEST_CONDITION_REQUIRED( planarCross->GetSingleLineMode(), "Testing activation of single-line mode" ); // Test placement of single-line PlanarCross by control points mitkPlanarCrossTestClass::TestPlanarCrossPlacementSingleLine( planarCross ); // ************************************************************************** // 3. Tests of application of spatial constraints for double-line mode planarCross = mitk::PlanarCross::New(); planarCross->SetGeometry2D( planeGeometry ); // Test placement with various out-of-bounds control points (automatic application of // constraints expected) mitkPlanarCrossTestClass::TestPlanarCrossPlacementConstrained( planarCross ); // ************************************************************************** // 4. Tests if editing of PlanarCross works as intended mitkPlanarCrossTestClass::TestPlanarCrossEdit( planarCross ); // always end with this! MITK_TEST_END() } diff --git a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp index 26fb620622..f6c5630c91 100644 --- a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp +++ b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp @@ -1,566 +1,566 @@ /*========================================================================= Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkTestingMacros.h" #include "mitkPlanarAngle.h" #include "mitkPlanarCircle.h" #include "mitkPlanarCross.h" #include "mitkPlanarFourPointAngle.h" #include "mitkPlanarLine.h" #include "mitkPlanarPolygon.h" #include "mitkPlanarRectangle.h" #include "mitkPlanarFigureWriter.h" #include "mitkPlanarFigureReader.h" #include "mitkPlaneGeometry.h" #include /** \brief Helper class for testing PlanarFigure reader and writer classes. */ class PlanarFigureIOTestClass { public: typedef std::list< mitk::PlanarFigure::Pointer > PlanarFigureList; typedef std::vector< mitk::PlanarFigureWriter::Pointer > PlanarFigureToMemoryWriterList; static PlanarFigureList CreatePlanarFigures() { PlanarFigureList planarFigures; // Create PlaneGeometry on which to place the PlanarFigures mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New(); planeGeometry->InitializeStandardPlane( 100.0, 100.0 ); // Create a few sample points for PlanarFigure placement mitk::Point2D p0; p0[0] = 20.0; p0[1] = 20.0; mitk::Point2D p1; p1[0] = 80.0; p1[1] = 80.0; mitk::Point2D p2; p2[0] = 90.0; p2[1] = 10.0; mitk::Point2D p3; p3[0] = 10.0; p3[1] = 90.0; // Create PlanarAngle mitk::PlanarAngle::Pointer planarAngle = mitk::PlanarAngle::New(); planarAngle->SetGeometry2D( planeGeometry ); planarAngle->PlaceFigure( p0 ); planarAngle->SetCurrentControlPoint( p1 ); planarAngle->AddControlPoint( p2 ); planarFigures.push_back( planarAngle.GetPointer() ); // Create PlanarCircle mitk::PlanarCircle::Pointer planarCircle = mitk::PlanarCircle::New(); planarCircle->SetGeometry2D( planeGeometry ); planarCircle->PlaceFigure( p0 ); planarCircle->SetCurrentControlPoint( p1 ); planarFigures.push_back( planarCircle.GetPointer() ); // Create PlanarCross mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New(); planarCross->SetSingleLineMode( false ); planarCross->SetGeometry2D( planeGeometry ); planarCross->PlaceFigure( p0 ); planarCross->SetCurrentControlPoint( p1 ); planarCross->AddControlPoint( p2 ); planarCross->AddControlPoint( p3 ); planarFigures.push_back( planarCross.GetPointer() ); // Create PlanarFourPointAngle mitk::PlanarFourPointAngle::Pointer planarFourPointAngle = mitk::PlanarFourPointAngle::New(); planarFourPointAngle->SetGeometry2D( planeGeometry ); planarFourPointAngle->PlaceFigure( p0 ); planarFourPointAngle->SetCurrentControlPoint( p1 ); planarFourPointAngle->AddControlPoint( p2 ); planarFourPointAngle->AddControlPoint( p3 ); planarFigures.push_back( planarFourPointAngle.GetPointer() ); // Create PlanarLine mitk::PlanarLine::Pointer planarLine = mitk::PlanarLine::New(); planarLine->SetGeometry2D( planeGeometry ); planarLine->PlaceFigure( p0 ); planarLine->SetCurrentControlPoint( p1 ); planarFigures.push_back( planarLine.GetPointer() ); // Create PlanarPolygon mitk::PlanarPolygon::Pointer planarPolygon = mitk::PlanarPolygon::New(); planarPolygon->SetClosed( false ); planarPolygon->SetGeometry2D( planeGeometry ); planarPolygon->PlaceFigure( p0 ); planarPolygon->SetCurrentControlPoint( p1 ); planarPolygon->AddControlPoint( p2 ); planarPolygon->AddControlPoint( p3 ); planarFigures.push_back( planarPolygon.GetPointer() ); // Create PlanarRectangle mitk::PlanarRectangle::Pointer planarRectangle = mitk::PlanarRectangle::New(); planarRectangle->SetGeometry2D( planeGeometry ); planarRectangle->PlaceFigure( p0 ); planarRectangle->SetCurrentControlPoint( p1 ); planarFigures.push_back( planarRectangle.GetPointer() ); //create preciseGeometry which is using float coordinates mitk::PlaneGeometry::Pointer preciseGeometry = mitk::PlaneGeometry::New(); mitk::Vector3D right; right[0] = 0.0; right[1] = 1.23456; right[2] = 0.0; mitk::Vector3D down; down[0] = 1.23456; down[1] = 0.0; down[2] = 0.0; mitk::Vector3D spacing; spacing[0] = 0.0123456; spacing[1] = 0.0123456; spacing[2] = 1.123456; preciseGeometry->InitializeStandardPlane( right, down, &spacing ); //convert points into the precise coordinates mitk::Point2D p0precise; p0precise[0] = p0[0] * spacing[0]; p0precise[1] = p0[1] * spacing[1]; mitk::Point2D p1precise; p1precise[0] = p1[0] * spacing[0]; p1precise[1] = p1[1] * spacing[1]; mitk::Point2D p2precise; p2precise[0] = p2[0] * spacing[0]; p2precise[1] = p2[1] * spacing[1]; mitk::Point2D p3precise; p3precise[0] = p3[0] * spacing[0]; p3precise[1] = p3[1] * spacing[1]; //Now all PlanarFigures are create using the precise Geometry // Create PlanarCross mitk::PlanarCross::Pointer nochncross = mitk::PlanarCross::New(); nochncross->SetSingleLineMode( false ); nochncross->SetGeometry2D( preciseGeometry ); nochncross->PlaceFigure( p0precise ); nochncross->SetCurrentControlPoint( p1precise ); nochncross->AddControlPoint( p2precise ); nochncross->AddControlPoint( p3precise ); planarFigures.push_back( nochncross.GetPointer() ); // Create PlanarAngle mitk::PlanarAngle::Pointer planarAnglePrecise = mitk::PlanarAngle::New(); planarAnglePrecise->SetGeometry2D( preciseGeometry ); planarAnglePrecise->PlaceFigure( p0precise ); planarAnglePrecise->SetCurrentControlPoint( p1precise ); planarAnglePrecise->AddControlPoint( p2precise ); planarFigures.push_back( planarAnglePrecise.GetPointer() ); // Create PlanarCircle mitk::PlanarCircle::Pointer planarCirclePrecise = mitk::PlanarCircle::New(); planarCirclePrecise->SetGeometry2D( preciseGeometry ); planarCirclePrecise->PlaceFigure( p0precise ); planarCirclePrecise->SetCurrentControlPoint( p1precise ); planarFigures.push_back( planarCirclePrecise.GetPointer() ); // Create PlanarFourPointAngle mitk::PlanarFourPointAngle::Pointer planarFourPointAnglePrecise = mitk::PlanarFourPointAngle::New(); planarFourPointAnglePrecise->SetGeometry2D( preciseGeometry ); planarFourPointAnglePrecise->PlaceFigure( p0precise ); planarFourPointAnglePrecise->SetCurrentControlPoint( p1precise ); planarFourPointAnglePrecise->AddControlPoint( p2precise ); planarFourPointAnglePrecise->AddControlPoint( p3precise ); planarFigures.push_back( planarFourPointAnglePrecise.GetPointer() ); // Create PlanarLine mitk::PlanarLine::Pointer planarLinePrecise = mitk::PlanarLine::New(); planarLinePrecise->SetGeometry2D( preciseGeometry ); planarLinePrecise->PlaceFigure( p0precise ); planarLinePrecise->SetCurrentControlPoint( p1precise ); planarFigures.push_back( planarLinePrecise.GetPointer() ); // Create PlanarPolygon mitk::PlanarPolygon::Pointer planarPolygonPrecise = mitk::PlanarPolygon::New(); planarPolygonPrecise->SetClosed( false ); planarPolygonPrecise->SetGeometry2D( preciseGeometry ); planarPolygonPrecise->PlaceFigure( p0precise ); planarPolygonPrecise->SetCurrentControlPoint( p1precise ); planarPolygonPrecise->AddControlPoint( p2precise ); planarPolygonPrecise->AddControlPoint( p3precise ); planarFigures.push_back( planarPolygonPrecise.GetPointer() ); // Create PlanarRectangle mitk::PlanarRectangle::Pointer planarRectanglePrecise = mitk::PlanarRectangle::New(); planarRectanglePrecise->SetGeometry2D( preciseGeometry ); planarRectanglePrecise->PlaceFigure( p0precise ); planarRectanglePrecise->SetCurrentControlPoint( p1precise ); planarFigures.push_back( planarRectanglePrecise.GetPointer() ); return planarFigures; } static PlanarFigureList CreateDeepCopiedPlanarFigures(PlanarFigureList original) { PlanarFigureList copiedPlanarFigures; PlanarFigureList::iterator it1; for ( it1 = original.begin(); it1 != original.end(); ++it1 ) { mitk::PlanarFigure::Pointer copiedFigure; if(strcmp((*it1)->GetNameOfClass(), "PlanarAngle") == 0) { copiedFigure = mitk::PlanarAngle::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarCircle") == 0) { copiedFigure = mitk::PlanarCircle::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarLine") == 0) { copiedFigure = mitk::PlanarLine::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarPolygon") == 0) { copiedFigure = mitk::PlanarPolygon::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarCross") == 0) { copiedFigure = mitk::PlanarCross::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarRectangle") == 0) { copiedFigure = mitk::PlanarRectangle::New(); } if(strcmp((*it1)->GetNameOfClass(), "PlanarFourPointAngle") == 0) { copiedFigure = mitk::PlanarFourPointAngle::New(); } copiedFigure->DeepCopy((*it1)); copiedPlanarFigures.push_back(copiedFigure.GetPointer()); } return copiedPlanarFigures; } static void VerifyPlanarFigures( PlanarFigureList &planarFigures1, PlanarFigureList &planarFigures2 ) { PlanarFigureList::iterator it1, it2; for ( it1 = planarFigures1.begin(); it1 != planarFigures1.end(); ++it1 ) { bool planarFigureFound = false; for ( it2 = planarFigures2.begin(); it2 != planarFigures2.end(); ++it2 ) { // Compare PlanarFigures (returns false if different types) if ( ComparePlanarFigures( *it1, *it2 ) ) { planarFigureFound = true; } } // Test if (at least) on PlanarFigure of the first type was found in the second list MITK_TEST_CONDITION_REQUIRED( planarFigureFound, "Testing if " << (*it1)->GetNameOfClass() << " has a counterpart" ); } } static bool ComparePlanarFigures( mitk::PlanarFigure* figure1, mitk::PlanarFigure* figure2 ) { // Test if PlanarFigures are of same type; otherwise return if ( strcmp( figure1->GetNameOfClass(), figure2->GetNameOfClass() ) != 0 ) { return false; } const char* figureName = figure1->GetNameOfClass(); // Test for equal number of control points if(figure1->GetNumberOfControlPoints() != figure2->GetNumberOfControlPoints()) { return false; } // Test if all control points are equal for ( unsigned int i = 0; i < figure1->GetNumberOfControlPoints(); ++i ) { - mitk::Point2D& point1 = figure1->GetControlPoint( i ); - mitk::Point2D& point2 = figure2->GetControlPoint( i ); + mitk::Point2D point1 = figure1->GetControlPoint( i ); + mitk::Point2D point2 = figure2->GetControlPoint( i ); if(point1.EuclideanDistanceTo( point2 ) >= mitk::eps) { return false; } } // Test for equal number of properties typedef mitk::PropertyList::PropertyMap PropertyMap; const PropertyMap* properties1 = figure1->GetPropertyList()->GetMap(); const PropertyMap* properties2 = figure2->GetPropertyList()->GetMap(); if(properties1->size() != properties2->size()) { return false; } MITK_INFO << "List 1:"; for (PropertyMap::const_iterator i1 = properties1->begin(); i1 != properties1->end(); ++i1) { std::cout << i1->first << std::endl; } MITK_INFO << "List 2:"; for (PropertyMap::const_iterator i2 = properties2->begin(); i2 != properties2->end(); ++i2) { std::cout << i2->first << std::endl; } MITK_INFO << "-------"; // Test if all properties are equal if(!std::equal( properties1->begin(), properties1->end(), properties2->begin(), PropertyMapEntryCompare() )) { return false; } // Test if Geometry is equal const mitk::PlaneGeometry* planeGeometry1 = dynamic_cast(figure1->GetGeometry2D()); const mitk::PlaneGeometry* planeGeometry2 = dynamic_cast(figure2->GetGeometry2D()); // Test Geometry transform parameters typedef mitk::AffineGeometryFrame3D::TransformType TransformType; const TransformType* affineGeometry1 = planeGeometry1->GetIndexToWorldTransform(); const TransformType::ParametersType& parameters1 = affineGeometry1->GetParameters(); const TransformType::ParametersType& parameters2 = planeGeometry2->GetIndexToWorldTransform()->GetParameters(); for ( unsigned int i = 0; i < affineGeometry1->GetNumberOfParameters(); ++i ) { if ( fabs(parameters1.GetElement( i ) - parameters2.GetElement( i )) >= mitk::eps ) { return false; } } // Test Geometry bounds typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType; const BoundsArrayType& bounds1 = planeGeometry1->GetBounds(); const BoundsArrayType& bounds2 = planeGeometry2->GetBounds(); for ( unsigned int i = 0; i < 6; ++i ) { if ( fabs(bounds1.GetElement( i ) - bounds2.GetElement( i )) >= mitk::eps ) { return false; }; } // Test Geometry spacing and origin mitk::Vector3D spacing1 = planeGeometry1->GetSpacing(); mitk::Vector3D spacing2 = planeGeometry2->GetSpacing(); if((spacing1 - spacing2).GetNorm() >= mitk::eps) { return false; } mitk::Point3D origin1 = planeGeometry1->GetOrigin(); mitk::Point3D origin2 = planeGeometry2->GetOrigin(); if(origin1.EuclideanDistanceTo( origin2 ) >= mitk::eps) { return false; } return true; } static void SerializePlanarFigures( PlanarFigureList &planarFigures, std::string& fileName ) { //std::string sceneFileName = Poco::Path::temp() + /*Poco::Path::separator() +*/ "scene.zip"; std::cout << "File name: " << fileName << std::endl; mitk::PlanarFigureWriter::Pointer writer = mitk::PlanarFigureWriter::New(); writer->SetFileName( fileName.c_str() ); unsigned int i; PlanarFigureList::iterator it; for ( it = planarFigures.begin(), i = 0; it != planarFigures.end(); ++it, ++i ) { writer->SetInput( i, *it ); } writer->Update(); MITK_TEST_CONDITION_REQUIRED( writer->GetSuccess(), "Testing if writing was successful"); } static PlanarFigureList DeserializePlanarFigures( std::string& fileName) { // Read in the planar figures mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New(); reader->SetFileName( fileName.c_str() ); reader->Update(); MITK_TEST_CONDITION_REQUIRED( reader->GetSuccess(), "Testing if reading was successful"); // Store them in the list and return it PlanarFigureList planarFigures; for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i ) { mitk::PlanarFigure* figure = reader->GetOutput( i ); planarFigures.push_back( figure ); } return planarFigures; } static PlanarFigureToMemoryWriterList SerializePlanarFiguresToMemoryBuffers( PlanarFigureList &planarFigures ) { PlanarFigureToMemoryWriterList pfMemoryWriters; unsigned int i; PlanarFigureList::iterator it; bool success = true; for ( it = planarFigures.begin(), i = 0; it != planarFigures.end(); ++it, ++i ) { mitk::PlanarFigureWriter::Pointer writer = mitk::PlanarFigureWriter::New(); writer->SetWriteToMemory( true ); writer->SetInput( *it ); writer->Update(); pfMemoryWriters.push_back(writer); if(!writer->GetSuccess()) success = false; } MITK_TEST_CONDITION_REQUIRED(success, "Testing if writing to memory buffers was successful"); return pfMemoryWriters; } static PlanarFigureList DeserializePlanarFiguresFromMemoryBuffers( PlanarFigureToMemoryWriterList pfMemoryWriters) { // Store them in the list and return it PlanarFigureList planarFigures; bool success = true; for ( unsigned int i = 0; i < pfMemoryWriters.size(); ++i ) { // Read in the planar figures mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New(); reader->SetReadFromMemory( true ); reader->SetMemoryBuffer(pfMemoryWriters[i]->GetMemoryPointer(), pfMemoryWriters[i]->GetMemorySize()); reader->Update(); mitk::PlanarFigure* figure = reader->GetOutput( 0 ); planarFigures.push_back( figure ); if(!reader->GetSuccess()) success = false; } MITK_TEST_CONDITION_REQUIRED(success, "Testing if reading was successful"); return planarFigures; } private: class PropertyMapEntryCompare { public: bool operator()( const mitk::PropertyList::PropertyMap::value_type &entry1, const mitk::PropertyList::PropertyMap::value_type &entry2 ) { MITK_INFO << "Comparing " << entry1.first << "(" << entry1.second.first->GetValueAsString() << ") and " << entry2.first << "(" << entry2.second.first->GetValueAsString() << ")"; // Compare property objects contained in the map entries (see mitk::PropertyList) return *(entry1.second.first) == *(entry2.second.first); } }; }; // end test helper class /** \brief Test for PlanarFigure reader and writer classes. * * The test works as follows: * * First, a number of PlanarFigure objects of different types are created and placed with * various control points. These objects are the serialized to file, read again from file, and * the retrieved objects are compared with their control points, properties, and geometry * information to the original PlanarFigure objects. */ int mitkPlanarFigureIOTest(int /* argc */, char* /*argv*/[]) { MITK_TEST_BEGIN("PlanarFigureIO"); // Create a number of PlanarFigure objects PlanarFigureIOTestClass::PlanarFigureList originalPlanarFigures = PlanarFigureIOTestClass::CreatePlanarFigures(); // Create a number of "deep-copied" planar figures to test the DeepCopy function PlanarFigureIOTestClass::PlanarFigureList copiedPlanarFigures = PlanarFigureIOTestClass::CreateDeepCopiedPlanarFigures(originalPlanarFigures); PlanarFigureIOTestClass::VerifyPlanarFigures(originalPlanarFigures, copiedPlanarFigures ); // Write PlanarFigure objects into temp file // tmpname static unsigned long count = 0; unsigned long n = count++; std::ostringstream name; for (int i = 0; i < 6; ++i) { name << char('a' + (n % 26)); n /= 26; } std::string myname; myname.append(name.str()); std::string fileName = itksys::SystemTools::GetCurrentWorkingDirectory() + myname + ".pf"; PlanarFigureIOTestClass::SerializePlanarFigures( originalPlanarFigures, fileName ); // Write PlanarFigure objects to memory buffers PlanarFigureIOTestClass::PlanarFigureToMemoryWriterList writersWithMemoryBuffers = PlanarFigureIOTestClass::SerializePlanarFiguresToMemoryBuffers( originalPlanarFigures ); // Read PlanarFigure objects from temp file PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFigures = PlanarFigureIOTestClass::DeserializePlanarFigures( fileName ); // Read PlanarFigure objects from memory buffers PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFiguresFromMemory = PlanarFigureIOTestClass::DeserializePlanarFiguresFromMemoryBuffers( writersWithMemoryBuffers ); PlanarFigureIOTestClass::PlanarFigureToMemoryWriterList::iterator it = writersWithMemoryBuffers.begin(); while(it != writersWithMemoryBuffers.end()) { (*it)->ReleaseMemory(); ++it; } // Test if original and retrieved PlanarFigure objects are the same PlanarFigureIOTestClass::VerifyPlanarFigures( originalPlanarFigures, retrievedPlanarFigures ); // Test if original and memory retrieved PlanarFigure objects are the same PlanarFigureIOTestClass::VerifyPlanarFigures( originalPlanarFigures, retrievedPlanarFiguresFromMemory ); //empty the originalPlanarFigures originalPlanarFigures.empty(); // Test if deep-copied and retrieved PlanarFigure objects are the same PlanarFigureIOTestClass::VerifyPlanarFigures( copiedPlanarFigures, retrievedPlanarFigures ); MITK_TEST_END() }