diff --git a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp index ab8fd0a3bb..26fb620622 100644 --- a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp +++ b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp @@ -1,499 +1,566 @@ /*========================================================================= - -Program: Medical Imaging & Interaction Toolkit -Language: C++ -Date: $Date$ -Version: $Revision: 1.12 $ - 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" ); + 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 - MITK_TEST_CONDITION_REQUIRED( - figure1->GetNumberOfControlPoints() == figure2->GetNumberOfControlPoints(), - figureName << ": Testing 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_TEST_CONDITION_REQUIRED( - point1.EuclideanDistanceTo( point2 ) < mitk::eps, - figureName << ": Testing equality of control point " << 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(); - MITK_TEST_CONDITION_REQUIRED( - properties1->size() == properties2->size(), - figureName << ": Testing number of properties" ); + 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 - MITK_TEST_CONDITION_REQUIRED( - std::equal( properties1->begin(), properties1->end(), properties2->begin(), PropertyMapEntryCompare() ), - figureName << ": Testing equality of properties"); - + 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 - bool parametersEqual = true; 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 ) + if ( fabs(parameters1.GetElement( i ) - parameters2.GetElement( i )) >= mitk::eps ) { - parametersEqual = false; + return false; } } - MITK_TEST_CONDITION_REQUIRED( - parametersEqual, - figureName << ": Testing if Geometry transform parameters are equal"); - - // Test Geometry bounds - bool boundsEqual = true; 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 ) + if ( fabs(bounds1.GetElement( i ) - bounds2.GetElement( i )) >= mitk::eps ) { - boundsEqual = false; + return false; }; } - MITK_TEST_CONDITION_REQUIRED( - boundsEqual, - figureName << ": Testing if Geometry bounds are equal"); - - // Test Geometry spacing and origin mitk::Vector3D spacing1 = planeGeometry1->GetSpacing(); mitk::Vector3D spacing2 = planeGeometry2->GetSpacing(); - - MITK_TEST_CONDITION_REQUIRED( - (spacing1 - spacing2).GetNorm() < mitk::eps, - figureName << ": Testing if Geometry spacing is equal"); - + if((spacing1 - spacing2).GetNorm() >= mitk::eps) + { + return false; + } mitk::Point3D origin1 = planeGeometry1->GetOrigin(); mitk::Point3D origin2 = planeGeometry2->GetOrigin(); - MITK_TEST_CONDITION_REQUIRED( - origin1.EuclideanDistanceTo( origin2 ) < mitk::eps, - figureName << ": Testing if Geometry origin are equal"); - - + 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 ) + it != planarFigures.end(); + ++it, ++i ) { writer->SetInput( i, *it ); } writer->Update(); MITK_TEST_CONDITION_REQUIRED( - writer->GetSuccess(), - "Testing if writing was successful"); + 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"); + 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 ) + 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 ) + 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") + MITK_TEST_BEGIN("PlanarFigureIO"); // Create a number of PlanarFigure objects - PlanarFigureIOTestClass::PlanarFigureList originalPlanarFigures = - PlanarFigureIOTestClass::CreatePlanarFigures(); + 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::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 ); + PlanarFigureIOTestClass::SerializePlanarFiguresToMemoryBuffers( originalPlanarFigures ); // Read PlanarFigure objects from temp file PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFigures = - PlanarFigureIOTestClass::DeserializePlanarFigures( fileName ); + PlanarFigureIOTestClass::DeserializePlanarFigures( fileName ); // Read PlanarFigure objects from memory buffers PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFiguresFromMemory = - PlanarFigureIOTestClass::DeserializePlanarFiguresFromMemoryBuffers( writersWithMemoryBuffers ); + 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() -} + }