X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=Testing%2FTestAllReadCompareDicom.cxx;h=56f5646b85814d3ae0bbb79aa6b1cabc31154077;hb=de5fc413dc579fc61f7e04397efd1dc1087fe3cf;hp=08abbcbf012f2525fd6c6a095732128a30c1cbbd;hpb=6c6608b98c9260180a08309c6049b9450658acad;p=gdcm.git diff --git a/Testing/TestAllReadCompareDicom.cxx b/Testing/TestAllReadCompareDicom.cxx index 08abbcbf..56f5646b 100644 --- a/Testing/TestAllReadCompareDicom.cxx +++ b/Testing/TestAllReadCompareDicom.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: TestAllReadCompareDicom.cxx,v $ Language: C++ - Date: $Date: 2005/02/01 13:42:44 $ - Version: $Revision: 1.29 $ + Date: $Date: 2005/04/19 10:05:36 $ + Version: $Revision: 1.39 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -20,19 +20,379 @@ #include "gdcmFileHelper.h" #include -#include //Generated file: #include "gdcmDataImages.h" -int InternalTest(std::string const & filename, - std::string const & referenceFileName ) +/** + * /brief File Read/Writer specific for the TestAllReadCompareDicom test + * /remarks The Test file format is (only in little endian) : + * - 4 bytes : 'gdcm' + * - 4 bytes : size X + * - 4 bytes : size Y + * - 4 bytes : size Z + * - 2 bytes : scalar size (8,16,32) + * - 2 bytes : number of components per pixel (1,2,3) + * - n bytes : datas + */ +class TestFile +{ +public: + TestFile(void); + ~TestFile(void); + + bool IsReadable(void) {return readable;} + int GetXSize(void) {return sizeX;}; + void SetXSize(int size) {sizeX = size;}; + int GetYSize(void) {return sizeY;}; + void SetYSize(int size) {sizeY = size;}; + int GetZSize(void) {return sizeZ;}; + void SetZSize(int size) {sizeZ = size;}; + int GetScalarSize(void) {return scalarSize;}; + void SetScalarSize(int size) {scalarSize = size;}; + int GetNumberOfComponents(void) {return components;}; + void SetNumberOfComponents(int size) {components = size;}; + + unsigned long GetDataSize(void) {return GetLineSize()*sizeY*sizeZ;} + uint8_t *GetData(void) {return data;} + void SetData(const uint8_t *newData); + + void Load(const std::string &filename); + void Write(const std::string &filename); + +private: + unsigned long GetLineSize(void) {return sizeX*scalarSize*components;} + int GetSwapCode(uint32_t tag); + + void NewData(void); + void DeleteData(void); + + void ReadFile(void); + bool ReadFileHeader(std::ifstream *fp); + bool ReadFileData(std::ifstream *fp); + void WriteFile(void); + bool WriteFileHeader(std::ofstream *fp); + bool WriteFileData(std::ofstream *fp); + + uint8_t ReadInt8 (std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ); +#else + ; +#endif + uint16_t ReadInt16(std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ); +#else + ; +#endif + uint32_t ReadInt32(std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ); +#else + ; +#endif + void WriteInt8 (std::ofstream *fp,uint8_t value); + void WriteInt16(std::ofstream *fp,uint16_t value); + void WriteInt32(std::ofstream *fp,uint32_t value); + + std::string fileName; + bool readable; + + int sizeX; + int sizeY; + int sizeZ; + uint16_t scalarSize; + uint16_t components; + uint8_t *data; + int swapCode; + + static const unsigned int HEADER_SIZE; +}; + +const unsigned int TestFile::HEADER_SIZE = 20; + +TestFile::TestFile(void) +{ + fileName = ""; + readable=false; + + sizeX = 0; + sizeY = 0; + sizeZ = 0; + scalarSize = 0; + components = 0; + data = NULL; + + swapCode = 1234; +} + +TestFile::~TestFile(void) +{ + DeleteData(); +} + +void TestFile::SetData(const uint8_t *newData) +{ + DeleteData(); + NewData(); + if( data ) + memcpy(data,newData,GetDataSize()); +} + +void TestFile::Load(const std::string &filename) +{ + fileName = filename; + ReadFile(); +} + +void TestFile::Write(const std::string &filename) +{ + fileName = filename; + WriteFile(); +} + +int TestFile::GetSwapCode(uint32_t tag) +{ + int swap = 0; + for(int i=0;i<4;i++) + { + switch(tag&0x000000FF) + { + case 'g': + swap += (i+1)*1000; + break; + case 'd': + swap += (i+1)*100; + break; + case 'c': + swap += (i+1)*10; + break; + case 'm': + swap += (i+1); + break; + default: + return 0; + } + tag >>= 8; + } + return swap; +} + +void TestFile::NewData(void) +{ + DeleteData(); + if( GetDataSize() == 0 ) + return; + data = new uint8_t[GetDataSize()]; +} + +void TestFile::DeleteData(void) +{ + if( data ) + delete[] data; + data = NULL; +} + +void TestFile::ReadFile(void) +{ + readable=true; + std::ifstream fp(fileName.c_str(),std::ios::in | std::ios::binary); + + if(!fp) + { + readable=false; + return; + } + + try + { + readable=ReadFileHeader(&fp); + if(!readable) + { + std::cout << "Problems when reading Header part" << std::endl; + fp.close(); + return; + } + + readable=ReadFileData(&fp); + if(!readable) + { + std::cout << "Problems when reading datas" << std::endl; + fp.close(); + return; + } + } + catch(...) + { + readable=false; + fp.close(); + return; + } + + fp.close(); +} + +bool TestFile::ReadFileHeader(std::ifstream *fp) +{ + uint32_t tag = ReadInt32(fp); + swapCode = GetSwapCode(tag); + if( swapCode == 0 ) + { + std::cout << "TestFile: Bad tag - Must be 'gdcm'" << std::endl; + return(false); + } + + sizeX = ReadInt32(fp); // Size X + sizeY = ReadInt32(fp); // Size Y + sizeZ = ReadInt32(fp); // Size Z + scalarSize = ReadInt16(fp)/8; // bits per scalar + components = ReadInt16(fp); // Number of components + + return(true); +} + +bool TestFile::ReadFileData(std::ifstream *fp) +{ + DeleteData(); + + // Allocate datas + NewData(); + if( !data ) + return(false); + + // Read datas + fp->read((char *)data,GetDataSize()); + + return(true); +} + +void TestFile::WriteFile(void) +{ + std::ofstream fp(fileName.c_str(),std::ios::out | std::ios::binary); + + if(!fp) + { + readable=false; + return; + } + + WriteFileHeader(&fp); + WriteFileData(&fp); + + fp.close(); +} + +bool TestFile::WriteFileHeader(std::ofstream *fp) +{ + WriteInt8(fp,'g'); // Bitmap tag - must be 'g' + WriteInt8(fp,'d'); // Bitmap tag - must be 'd' + WriteInt8(fp,'c'); // Bitmap tag - must be 'c' + WriteInt8(fp,'m'); // Bitmap tag - must be 'm' + WriteInt32(fp,sizeX); // Size X + WriteInt32(fp,sizeY); // Size Y + WriteInt32(fp,sizeZ); // Size Z + WriteInt16(fp,scalarSize*8); // bits per scalar + WriteInt16(fp,components); // number of components + + return(true); +} + +bool TestFile::WriteFileData(std::ofstream *fp) +{ + fp->write((char *)data,GetDataSize()); + + return(true); +} + +uint8_t TestFile::ReadInt8 (std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ) +#endif +{ + uint8_t g; + fp->read ((char*)&g, (size_t)1); +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + if ( fp->fail() ) + throw std::ios::failure( "TestFile::ReadInt8() - file error." ); + if( fp->eof() ) + throw std::ios::failure( "TestFile::ReadInt8() - EOF." ); +#endif + return g; +} + +uint16_t TestFile::ReadInt16(std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ) +#endif +{ + uint16_t g; + fp->read ((char*)&g, (size_t)2); +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + if ( fp->fail() ) + throw std::ios::failure( "TestFile::ReadInt16() - file error." ); + if( fp->eof() ) + throw std::ios::failure( "TestFile::ReadInt16() - EOF." ); +#endif + +#if defined(GDCM_WORDS_BIGENDIAN) + g = ( g << 8 | g >> 8 ); +#endif + return g; +} + +uint32_t TestFile::ReadInt32(std::ifstream *fp) +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + throw( std::ios::failure ) +#endif +{ + uint32_t g; + fp->read ((char*)&g, (size_t)4); +#if !(__GNUC__==2 && __GNUC_MINOR__<=96) + if ( fp->fail() ) + throw std::ios::failure( "TestFile::ReadInt32() - file error." ); + if( fp->eof() ) + throw std::ios::failure( "TestFile::ReadInt32() - EOF." ); +#endif + +#if defined(GDCM_WORDS_BIGENDIAN) + g = ( (g<<24) | ((g<<8) & 0x00ff0000) | + ( (g>>8) & 0x0000ff00) | (g>>24) ); +#endif + return g; +} + +void TestFile::WriteInt8 (std::ofstream *fp,uint8_t value) +{ + fp->write((char*)&value, (size_t)1); +} + +void TestFile::WriteInt16(std::ofstream *fp,uint16_t value) +{ +#if defined(GDCM_WORDS_BIGENDIAN) + value = ( value << 8 | value >> 8 ); +#endif + fp->write((char*)&value, (size_t)2); +} + +void TestFile::WriteInt32(std::ofstream *fp,uint32_t value) +{ +#if defined(GDCM_WORDS_BIGENDIAN) + value = ( (value<<24) | ((value<<8) & 0x00ff0000) | + ( (value>>8) & 0x0000ff00) | (value>>24) ); +#endif + fp->write((char*)&value, (size_t)4); +} + +int InternalTest(std::string const &filename, + std::string const &referenceFileName ) { std::cout << " Testing: " << filename << std::endl; + std::cout << " "; ////// Step 1: - std::cout << " 1..."; - gdcm::FileHelper* tested = new gdcm::FileHelper( filename ); + std::cout << "1..."; + gdcm::FileHelper *tested = new gdcm::FileHelper( filename ); if( !tested->GetFile()->IsReadable() ) { std::cout << " Failed" << std::endl @@ -46,56 +406,73 @@ int InternalTest(std::string const & filename, ////// Check for existence of reference baseline dicom file: std::cout << "2..."; - std::ifstream testFILE( referenceFileName.c_str() ); - if (! testFILE ) + TestFile *reference = new TestFile(); + std::ifstream refFile(referenceFileName.c_str(), + std::ios::binary|std::ios::in); + if(!refFile) { - uint8_t* testedImageData = tested->GetImageData(); // Kludge - (void)testedImageData; - - tested->SetWriteModeToRGB(); - tested->WriteDcmExplVR( referenceFileName ); + std::cout << " Failed" << std::endl + << " Image not found:" + << referenceFileName << std::endl; + reference->SetXSize(tested->GetFile()->GetXSize()); + reference->SetYSize(tested->GetFile()->GetYSize()); + reference->SetZSize(tested->GetFile()->GetZSize()); + reference->SetScalarSize(tested->GetFile()->GetPixelSize()); + reference->SetNumberOfComponents(tested->GetFile()->GetNumberOfScalarComponents()); + reference->SetData(tested->GetImageData()); + reference->Write(referenceFileName); } - testFILE.close(); - - ////// Step 3a: - ////// When reference file is not gdcm readable test is failed: - std::cout << "3a..."; + else + refFile.close(); - gdcm::FileHelper* reference = new gdcm::FileHelper( referenceFileName ); - if( !reference->GetFile()->IsReadable() ) + reference->Load(referenceFileName); + if(!reference->IsReadable()) { - std::cout << " Failed" << std::endl - << " reference image " - << referenceFileName - << " is not gdcm compatible." << std::endl; - delete tested; + std::cout << " Failed" << std::endl + << " Image not Testing compatible:" + << filename << std::endl; delete reference; + delete tested; return 1; } - std::string PixelType = reference->GetFile()->GetPixelType(); - - ////// Step 3b: - std::cout << "3b..."; + ////// Step 3: + std::string PixelType = tested->GetFile()->GetPixelType(); + std::cout << "3..."; int testedDataSize = tested->GetImageDataSize(); - uint8_t* testedImageData = tested->GetImageData(); + uint8_t *testedImageData = tested->GetImageData(); - int referenceDataSize = reference->GetImageDataSize(); - uint8_t* referenceImageData = reference->GetImageData(); + int referenceDataSize = reference->GetDataSize(); + uint8_t *referenceImageData = reference->GetData(); // Test the image size - if (tested->GetFile()->GetXSize() != reference->GetFile()->GetXSize() || - tested->GetFile()->GetYSize() != reference->GetFile()->GetYSize() || - tested->GetFile()->GetZSize() != reference->GetFile()->GetZSize()) + if (tested->GetFile()->GetXSize() != reference->GetXSize() || + tested->GetFile()->GetYSize() != reference->GetYSize() || + tested->GetFile()->GetZSize() != reference->GetZSize()) + { + std::cout << "Failed" << std::endl + << " Size differs: " + << "X: " << tested->GetFile()->GetXSize() << " # " + << reference->GetXSize() << " | " + << "Y: " << tested->GetFile()->GetYSize() << " # " + << reference->GetYSize() << " | " + << "Z: " << tested->GetFile()->GetZSize() << " # " + << reference->GetZSize() << std::endl; + delete reference; + delete tested; + return 1; + } + + // Test the pixel size + if (tested->GetFile()->GetPixelSize() != reference->GetScalarSize() || + tested->GetFile()->GetNumberOfScalarComponents() != reference->GetNumberOfComponents()) { std::cout << "Failed" << std::endl - << " Size differs: " - << "X: " << tested->GetFile()->GetXSize() << " # " - << reference->GetFile()->GetXSize() << " | " - << "Y: " << tested->GetFile()->GetYSize() << " # " - << reference->GetFile()->GetYSize() << " | " - << "Z: " << tested->GetFile()->GetZSize() << " # " - << reference->GetFile()->GetZSize() << std::endl; + << " Pixel size differs: " << std::endl + << " Scalar size: " << tested->GetFile()->GetPixelSize() << " # " + << reference->GetScalarSize() << std::endl + << " Number of scalar: " << tested->GetFile()->GetNumberOfScalarComponents() << " # " + << reference->GetNumberOfComponents() << std::endl; delete reference; delete tested; return 1; @@ -109,6 +486,11 @@ int InternalTest(std::string const & filename, << PixelType <<") areas lengths differ: " << testedDataSize << " # " << referenceDataSize + << std::endl + << " Image size: (" + << tested->GetFile()->GetXSize() << "," + << tested->GetFile()->GetYSize() << "," + << tested->GetFile()->GetZSize() << ")" << std::endl; delete tested; delete reference; @@ -139,7 +521,7 @@ int InternalTest(std::string const & filename, return 0; } -int TestAllReadCompareDicom(int argc, char* argv[]) +int TestAllReadCompareDicom(int argc, char *argv[]) { if ( argc == 3 ) { @@ -195,7 +577,7 @@ int TestAllReadCompareDicom(int argc, char* argv[]) ////// Check for existence of reference baseline directory std::string baseLineDir = GDCM_DATA_ROOT; - baseLineDir += "/BaselineDicom/"; + baseLineDir += "/BaselineDicom"; if( !gdcm::DirList::IsDirectory(baseLineDir) ) { @@ -212,11 +594,12 @@ int TestAllReadCompareDicom(int argc, char* argv[]) filename += "/"; filename += gdcmDataImages[i]; + baseLineDir += '/'; std::string referenceFileName = baseLineDir + gdcmDataImages[i++]; std::string::size_type slash_pos = referenceFileName.rfind( "." ); if( slash_pos != std::string::npos ) { - referenceFileName.replace( slash_pos + 1, 3, "dcm" ); + referenceFileName.replace( slash_pos + 1, 3, "tst" ); } if( InternalTest( filename, referenceFileName ) != 0 )