00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "mitkTestingMacros.h"
00019 #include "mitkTestingConfig.h"
00020
00021 #include "mitkSceneIO.h"
00022
00023 #include "mitkStandaloneDataStorage.h"
00024 #include "mitkStandardFileLocations.h"
00025 #include "mitkDataNodeFactory.h"
00026 #include "mitkCoreObjectFactory.h"
00027 #include "mitkBaseData.h"
00028 #include "mitkImage.h"
00029 #include "mitkSurface.h"
00030 #include "mitkPointSet.h"
00031 #include "Poco/File.h"
00032 #include "Poco/TemporaryFile.h"
00033
00034 #ifndef WIN32
00035 #include <ulimit.h>
00036 #include <errno.h>
00037 #endif
00038
00039 class SceneIOTestClass
00040 {
00041 public:
00042
00044 static std::string LocateFile(const std::string& filename)
00045 {
00046 mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
00047 MITK_TEST_CONDITION_REQUIRED(locator.IsNotNull(),"Instantiating StandardFileLocations")
00048 return locator->FindFile(filename.c_str(), "Core/Code/Testing/Data");
00049 }
00050
00051 static mitk::BaseData::Pointer LoadBaseData(const std::string& filename)
00052 {
00053 mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
00054 try
00055 {
00056 factory->SetFileName( filename );
00057 factory->Update();
00058
00059 if(factory->GetNumberOfOutputs()<1)
00060 {
00061 MITK_TEST_FAILED_MSG(<< "Could not find test data '" << filename << "'");
00062 }
00063
00064 mitk::DataNode::Pointer node = factory->GetOutput( 0 );
00065 return node->GetData();
00066 }
00067 catch ( itk::ExceptionObject & e )
00068 {
00069 MITK_TEST_FAILED_MSG(<< "Failed loading test data '" << filename << "': " << e.what());
00070 }
00071 }
00072
00073 static mitk::Image::Pointer LoadImage(const std::string& filename)
00074 {
00075 mitk::BaseData::Pointer basedata = LoadBaseData( filename );
00076 mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(basedata.GetPointer());
00077 if(image.IsNull())
00078 {
00079 MITK_TEST_FAILED_MSG(<< "Test image '" << filename << "' was not loaded as an mitk::Image");
00080 }
00081 return image;
00082 }
00083
00084 static mitk::Surface::Pointer LoadSurface(const std::string& filename)
00085 {
00086 mitk::BaseData::Pointer basedata = LoadBaseData( filename );
00087 mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(basedata.GetPointer());
00088 if(surface.IsNull())
00089 {
00090 MITK_TEST_FAILED_MSG(<< "Test surface '" << filename << "' was not loaded as an mitk::Surface");
00091 }
00092 return surface;
00093 }
00094
00095 static mitk::PointSet::Pointer CreatePointSet()
00096 {
00097
00098 mitk::PointSet::Pointer ps = mitk::PointSet::New();
00099 mitk::PointSet::PointType p;
00100 mitk::FillVector3D(p, 1.0, -2.0, 33.0);
00101 ps->SetPoint(0, p);
00102 mitk::FillVector3D(p, 100.0, -200.0, 3300.0);
00103 ps->SetPoint(1, p);
00104 mitk::FillVector3D(p, 2.0, -3.0, 22.0);
00105 ps->SetPoint(2, p, mitk::PTCORNER);
00106
00107
00108
00109
00110
00111
00112 return ps;
00113 }
00114
00115 static void FillStorage(mitk::DataStorage* storage)
00116 {
00117 mitk::Image::Pointer image = LoadImage( LocateFile("Pic3D.pic.gz") );
00118 MITK_TEST_CONDITION_REQUIRED(image.IsNotNull(),"Loading test image Pic3D.pic.gz");
00119
00120 image->SetProperty("image type", mitk::StringProperty::New("test image") );
00121 image->SetProperty("greetings", mitk::StringProperty::New("to mom") );
00122
00123 mitk::DataNode::Pointer imagenode = mitk::DataNode::New();
00124 imagenode->SetData( image );
00125 imagenode->SetName( "Pic3D" );
00126 storage->Add( imagenode );
00127
00128 mitk::DataNode::Pointer imagechildnode = mitk::DataNode::New();
00129 imagechildnode->SetData( image );
00130 imagechildnode->SetName( "Pic3D again" );
00131 storage->Add( imagechildnode, imagenode );
00132
00133
00134 mitk::Surface::Pointer surface = LoadSurface( LocateFile("binary.stl") );
00135 MITK_TEST_CONDITION_REQUIRED(surface.IsNotNull(),"Loading test surface binary.stl");
00136
00137 surface->SetProperty("surface type", mitk::StringProperty::New("test surface") );
00138 surface->SetProperty("greetings", mitk::StringProperty::New("to dad") );
00139
00140 mitk::DataNode::Pointer surfacenode = mitk::DataNode::New();
00141 surfacenode->SetData( surface );
00142 surfacenode->SetName( "binary" );
00143 storage->Add( surfacenode );
00144
00145 mitk::PointSet::Pointer ps = CreatePointSet();
00146 mitk::DataNode::Pointer psenode = mitk::DataNode::New();
00147 psenode->SetData( ps );
00148 psenode->SetName( "points" );
00149 storage->Add( psenode );
00150
00151 }
00152
00153 static void VerifyStorage(mitk::DataStorage* storage)
00154 {
00155
00156 mitk::DataNode::Pointer imagenode = storage->GetNamedNode("Pic3D");
00157 MITK_TEST_CONDITION_REQUIRED(imagenode.IsNotNull(),"Get previously stored image node");
00158
00159
00160 std::string testString("");
00161 imagenode->GetStringProperty("image type", testString);
00162 MITK_TEST_CONDITION_REQUIRED(!(testString == "test image") ,"Get StringProperty from previously stored image node");
00163
00164 imagenode->GetStringProperty("greetings", testString);
00165 MITK_TEST_CONDITION_REQUIRED(!(testString == "to mom") ,"Get another StringProperty from previously stored image node");
00166
00167 mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(imagenode->GetData());
00168 MITK_TEST_CONDITION_REQUIRED(image.IsNotNull(),"Loading test image from Datastorage");
00169
00170
00171 mitk::DataNode::Pointer imagechildnode = storage->GetNamedNode("Pic3D again");
00172 mitk::DataStorage::SetOfObjects::ConstPointer objects = storage->GetSources(imagechildnode);
00173
00174 MITK_TEST_CONDITION_REQUIRED(objects->Size() == 1,"Check size of image child nodes source list");
00175 MITK_TEST_CONDITION_REQUIRED(objects->ElementAt(0) == imagenode,"Check for right parent node");
00176
00177 mitk::Image::Pointer imagechild = dynamic_cast<mitk::Image*>(imagechildnode->GetData());
00178 MITK_TEST_CONDITION_REQUIRED(imagechild.IsNotNull(),"Loading child test image from Datastorage");
00179
00180
00181 mitk::DataNode::Pointer surfacenode = storage->GetNamedNode("binary");
00182 MITK_TEST_CONDITION_REQUIRED(surfacenode.IsNotNull(),"Get previously stored surface node");
00183
00184 surfacenode->GetStringProperty("surface type", testString);
00185 MITK_TEST_CONDITION_REQUIRED(!(testString.compare("test surface") == 0) ,"Get StringProperty from previously stored surface node");
00186
00187 surfacenode->GetStringProperty("greetings", testString);
00188 MITK_TEST_CONDITION_REQUIRED(!(testString.compare("to dad") == 0) ,"Get another StringProperty from previously stored surface node");
00189
00190 mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(surfacenode->GetData());
00191 MITK_TEST_CONDITION_REQUIRED(surface.IsNotNull(),"Loading test surface from Datastorage");
00192
00193
00194
00195 mitk::DataNode::Pointer pointsnode = storage->GetNamedNode("points");
00196 MITK_TEST_CONDITION_REQUIRED(pointsnode.IsNotNull(),"Get previously stored PointSet node");
00197
00198 mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(pointsnode->GetData());
00199 MITK_TEST_CONDITION_REQUIRED(pointset.IsNotNull(),"Loading test PointSet from Datastorage");
00200
00201 mitk::PointSet::PointType p = pointset->GetPoint(0);
00202 MITK_TEST_CONDITION_REQUIRED(p[0] == 1.0 && p[1] == -2.0 && p[2] == 33.0, "Test Pointset entry 0 after loading");
00203
00204 p = pointset->GetPoint(1);
00205 MITK_TEST_CONDITION_REQUIRED(p[0] == 100.0 && p[1] == -200.0 && p[2] == 3300.0, "Test Pointset entry 1 after loading");
00206
00207 p = pointset->GetPoint(2);
00208 MITK_TEST_CONDITION_REQUIRED(p[0] == 2.0 && p[1] == -3.0 && p[2] == 22.0, "Test Pointset entry 2 after loading");
00209
00210 }
00211 };
00212
00213 int mitkSceneIOTest(int , char* [])
00214 {
00215 MITK_TEST_BEGIN("SceneIO")
00216 std::string sceneFileName;
00217
00218 for (unsigned int i = 0; i < 1; ++i)
00219 {
00220 if (i == 1)
00221 {
00222
00223 #ifndef WIN32
00224 errno = 0;
00225 long int value = ulimit(UL_SETFSIZE, 1);
00226 MITK_TEST_CONDITION_REQUIRED( value != -1, "ulimit() returned with errno = " << errno );
00227 #else
00228 continue;
00229 #endif
00230 }
00231
00232
00233 mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
00234 MITK_TEST_CONDITION_REQUIRED(sceneIO.IsNotNull(),"SceneIO instantiation")
00235
00236 mitk::DataStorage::Pointer storage = mitk::StandaloneDataStorage::New().GetPointer();
00237 MITK_TEST_CONDITION_REQUIRED(storage.IsNotNull(),"StandaloneDataStorage instantiation");
00238
00239 SceneIOTestClass::FillStorage(storage);
00240
00241
00242 Poco::Path newname( Poco::TemporaryFile::tempName() );
00243 sceneFileName = std::string( MITK_TEST_OUTPUT_DIR ) + Poco::Path::separator() + newname.getFileName() + ".zip";
00244 MITK_TEST_CONDITION_REQUIRED( sceneIO->SaveScene( storage->GetAll(), storage, sceneFileName), "Saving scene file '" << sceneFileName << "'");
00245
00246
00247 mitk::SceneIO::FailedBaseDataListType::ConstPointer failedNodes = sceneIO->GetFailedNodes();
00248 if (failedNodes.IsNotNull() && !failedNodes->empty())
00249 {
00250 MITK_TEST_OUTPUT( << "The following nodes could not be serialized:");
00251 for ( mitk::SceneIO::FailedBaseDataListType::const_iterator iter = failedNodes->begin();
00252 iter != failedNodes->end();
00253 ++iter )
00254 {
00255 MITK_TEST_OUTPUT_NO_ENDL( << " - ");
00256 if ( mitk::BaseData* data =(*iter)->GetData() )
00257 {
00258 MITK_TEST_OUTPUT_NO_ENDL( << data->GetNameOfClass());
00259 }
00260 else
00261 {
00262 MITK_TEST_OUTPUT_NO_ENDL( << "(NULL)");
00263 }
00264
00265 MITK_TEST_OUTPUT( << " contained in node '" << (*iter)->GetName() << "'");
00266
00267 }
00268 }
00269
00270 mitk::PropertyList::ConstPointer failedProperties = sceneIO->GetFailedProperties();
00271 if (failedProperties.IsNotNull() && !failedProperties->IsEmpty())
00272 {
00273 MITK_TEST_OUTPUT( << "The following properties could not be serialized:");
00274 const mitk::PropertyList::PropertyMap* propmap = failedProperties->GetMap();
00275 for ( mitk::PropertyList::PropertyMap::const_iterator iter = propmap->begin();
00276 iter != propmap->end();
00277 ++iter )
00278 {
00279 MITK_TEST_OUTPUT( << " - " << iter->second.first->GetNameOfClass() << " associated to key '" << iter->first << "'");
00280
00281 }
00282 }
00283 MITK_TEST_CONDITION_REQUIRED(failedProperties.IsNotNull() && failedProperties->IsEmpty(), "Checking if all properties have been saved.")
00284 MITK_TEST_CONDITION_REQUIRED(failedNodes.IsNotNull() && failedNodes->empty(), "Checking if all nodes have been saved.")
00285
00286
00287 sceneIO = mitk::SceneIO::New();
00288
00289
00290 MITK_TEST_OUTPUT(<< "Loading scene again");
00291 storage = sceneIO->LoadScene(sceneFileName,storage,true);
00292
00293
00294 failedNodes = sceneIO->GetFailedNodes();
00295 if (failedNodes.IsNotNull() && !failedNodes->empty())
00296 {
00297 MITK_TEST_OUTPUT( << "The following nodes could not be serialized:");
00298 for ( mitk::SceneIO::FailedBaseDataListType::const_iterator iter = failedNodes->begin();
00299 iter != failedNodes->end();
00300 ++iter )
00301 {
00302 MITK_TEST_OUTPUT_NO_ENDL( << " - ");
00303 if ( mitk::BaseData* data =(*iter)->GetData() )
00304 {
00305 MITK_TEST_OUTPUT_NO_ENDL( << data->GetNameOfClass());
00306 }
00307 else
00308 {
00309 MITK_TEST_OUTPUT_NO_ENDL( << "(NULL)");
00310 }
00311
00312 MITK_TEST_OUTPUT( << " contained in node '" << (*iter)->GetName() << "'");
00313
00314 }
00315 }
00316
00317 failedProperties = sceneIO->GetFailedProperties();
00318 if (failedProperties.IsNotNull() && !failedProperties->IsEmpty())
00319 {
00320 MITK_TEST_OUTPUT( << "The following properties could not be serialized:");
00321 const mitk::PropertyList::PropertyMap* propmap = failedProperties->GetMap();
00322 for ( mitk::PropertyList::PropertyMap::const_iterator iter = propmap->begin();
00323 iter != propmap->end();
00324 ++iter )
00325 {
00326 MITK_TEST_OUTPUT( << " - " << iter->second.first->GetNameOfClass() << " associated to key '" << iter->first << "'");
00327
00328 }
00329 }
00330
00331
00332 SceneIOTestClass::VerifyStorage(storage);
00333
00334 }
00335
00336 if ( mitk::TestManager::GetInstance()->NumberOfFailedTests() == 0 )
00337 {
00338 Poco::File pocoSceneFile( sceneFileName );
00339 MITK_TEST_CONDITION_REQUIRED( pocoSceneFile.exists(), "Checking if scene file still exists before cleaning up." )
00340 pocoSceneFile.remove();
00341 }
00342 MITK_TEST_END();
00343 }
00344