1 /*=========================================================================
2 *
3 * Copyright Insight Software Consortium
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0.txt
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *=========================================================================*/
18
19 #include <fstream>
20 #include "itkRawImageIO.h"
21 #include "itkImageFileReader.h"
22 #include "itkImageFileWriter.h"
23
24
25 // Specific ImageIO test
26
27 template <typename TPixel>
28 class RawImageReaderAndWriter
29 {
30 public:
31
32 using PixelType = unsigned char;
33
34 using RawImageIOType = itk::RawImageIO< PixelType, 2 >;
35
36 using ImageType = itk::Image< PixelType, 2 >;
37
38 public:
39
RawImageReaderAndWriter()40 RawImageReaderAndWriter()
41 {
42 m_Image = ImageType::New();
43
44 typename ImageType::RegionType region;
45 typename ImageType::SizeType size;
46 typename ImageType::IndexType start;
47
48 start.Fill(0);
49 size[0] = 16; // To fill the range of 8 bits image
50 size[1] = 16;
51
52 region.SetSize( size );
53 region.SetIndex( start );
54
55 m_Image->SetRegions( region );
56 m_Image->Allocate();
57
58 PixelType value = itk::NumericTraits< PixelType >::ZeroValue();
59
60 // Fill the image with incremental values.
61 using IteratorType = itk::ImageRegionIterator< ImageType >;
62 IteratorType it( m_Image, region );
63
64 it.GoToBegin();
65
66 while( !it.IsAtEnd() )
67 {
68 it.Set( value );
69 ++value;
70 ++it;
71 }
72
73 m_Error = false;
74
75 }
76
Write()77 void Write()
78 {
79 using WriterType = itk::ImageFileWriter< ImageType >;
80 WriterType::Pointer writer = WriterType::New();
81
82 writer->SetFileName( m_FileName.c_str() );
83 writer->SetInput( m_Image );
84
85 RawImageIOType::Pointer rawImageIO = RawImageIOType::New();
86 writer->SetImageIO( rawImageIO );
87
88 writer->Update();
89 }
90
Read()91 void Read()
92 {
93 using ReaderType = itk::ImageFileReader< ImageType >;
94 ReaderType::Pointer reader = ReaderType::New();
95 reader->SetFileName( m_FileName.c_str() );
96
97 RawImageIOType::Pointer rawImageIO = RawImageIOType::New();
98 reader->SetImageIO( rawImageIO );
99
100 unsigned int dim[2] = {16,16};
101 double spacing[2] = {1.0, 1.0};
102 double origin[2] = {0.0,0.0};
103
104 for(unsigned int i=0; i<2; i++)
105 {
106 rawImageIO->SetDimensions(i,dim[i]);
107 rawImageIO->SetSpacing(i,spacing[i]);
108 rawImageIO->SetOrigin(i,origin[i]);
109 }
110
111 rawImageIO->SetHeaderSize(0);
112 rawImageIO->SetByteOrderToLittleEndian();
113 rawImageIO->SetNumberOfComponents(1);
114
115 reader->Update();
116
117 ImageType::ConstPointer image = reader->GetOutput();
118
119
120 //
121 // Verify the content of the image.
122 //
123 using ConstIteratorType = itk::ImageRegionConstIterator< ImageType >;
124
125 ConstIteratorType it1( m_Image, m_Image->GetLargestPossibleRegion() );
126 ConstIteratorType it2( image, image->GetLargestPossibleRegion() );
127
128 it1.GoToBegin();
129 it2.GoToBegin();
130
131 m_Error = false;
132
133 while( it1.IsAtEnd() )
134 {
135 if( it1.Get() != it2.Get() )
136 {
137 m_Error = true;
138 break;
139 }
140 ++it1;
141 ++it2;
142 }
143
144
145 }
146
SetFileName(const std::string & filename)147 void SetFileName( const std::string & filename )
148 {
149 m_FileName = filename;
150 }
151
GetError() const152 bool GetError() const
153 {
154 return m_Error;
155 }
156
157 private:
158
159 std::string m_FileName;
160
161 typename ImageType::Pointer m_Image;
162
163 bool m_Error;
164
165 };
166
itkRawImageIOTest5(int argc,char * argv[])167 int itkRawImageIOTest5(int argc, char*argv[])
168 {
169
170 if(argc < 2)
171 {
172 std::cerr << "Usage: " << std::endl;
173 std::cerr << argv[0] << " TemporaryDirectoryName" << std::endl;
174 return EXIT_FAILURE;
175 }
176
177
178 std::string directory = argv[1];
179
180
181 //
182 // Test the pixel type = "char"
183 //
184 std::cout << "Testing for pixel type = char " << std::endl;
185
186
187 RawImageReaderAndWriter< char > tester1;
188
189
190 std::string filename = directory + "/RawImageIOTest5a.raw";
191
192 tester1.SetFileName( filename );
193
194
195 try
196 {
197 tester1.Write();
198 }
199 catch( itk::ExceptionObject & excp )
200 {
201 std::cerr << "Exception caught while writing char type." << std::endl;
202 std::cerr << excp << std::endl;
203 return EXIT_FAILURE;
204 }
205
206
207 try
208 {
209 tester1.Read();
210 }
211 catch( itk::ExceptionObject & excp )
212 {
213 std::cerr << "Exception caught while reading char type." << std::endl;
214 std::cerr << excp << std::endl;
215 return EXIT_FAILURE;
216 }
217
218 if( tester1.GetError() )
219 {
220 std::cerr << "Error while comparing the char type images." << std::endl;
221 return EXIT_FAILURE;
222 }
223
224 //
225 // Test the pixel type = "signed char"
226 //
227 std::cout << "Testing for pixel type = signed char " << std::endl;
228
229 RawImageReaderAndWriter< signed char > tester2;
230
231 filename = directory + "/RawImageIOTest5b.raw";
232
233 tester2.SetFileName( filename );
234
235
236 try
237 {
238 tester2.Write();
239 }
240 catch( itk::ExceptionObject & excp )
241 {
242 std::cerr << "Exception caught while writing signed char type." << std::endl;
243 std::cerr << excp << std::endl;
244 return EXIT_FAILURE;
245 }
246
247
248 try
249 {
250 tester2.Read();
251 }
252 catch( itk::ExceptionObject & excp )
253 {
254 std::cerr << "Exception caught while reading signed char type." << std::endl;
255 std::cerr << excp << std::endl;
256 return EXIT_FAILURE;
257 }
258
259 if( tester2.GetError() )
260 {
261 std::cerr << "Error while comparing the signed char type images." << std::endl;
262 return EXIT_FAILURE;
263 }
264
265 //
266 // Test the pixel type = "unsigned char"
267 //
268 std::cout << "Testing for pixel type = unsigned char " << std::endl;
269
270 RawImageReaderAndWriter< unsigned char > tester3;
271
272
273 filename = directory + "/RawImageIOTest5c.raw";
274
275 tester3.SetFileName( filename );
276
277
278 try
279 {
280 tester3.Write();
281 }
282 catch( itk::ExceptionObject & excp )
283 {
284 std::cerr << "Exception caught while writing unsigned char type." << std::endl;
285 std::cerr << excp << std::endl;
286 return EXIT_FAILURE;
287 }
288
289
290 try
291 {
292 tester3.Read();
293 }
294 catch( itk::ExceptionObject & excp )
295 {
296 std::cerr << "Exception caught while reading unsigned char type." << std::endl;
297 std::cerr << excp << std::endl;
298 return EXIT_FAILURE;
299 }
300
301 if( tester3.GetError() )
302 {
303 std::cerr << "Error while comparing the unsigned char type images." << std::endl;
304 return EXIT_FAILURE;
305 }
306
307 std::cout << "Test PASSED !!" << std::endl << std::endl;
308
309 return EXIT_SUCCESS;
310
311 }
312