]> Creatis software - clitk.git/blob - common/rtkEdfImageIO.cxx
itk4.3 compatibility
[clitk.git] / common / rtkEdfImageIO.cxx
1 /*=========================================================================
2  *
3  *  Copyright RTK 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 "rtkEdfImageIO.h"
20
21 // itk include (for itkReadRawBytesAfterSwappingMacro)
22 #include <itkRawImageIO.h>
23 #include <itk_zlib.h>
24
25 //--------------------------------------------------------------------
26 /* Find value_ptr as pointer to the parameter of the given key in the header.
27  * Returns NULL on success.
28  */
29 char*
30 rtk::EdfImageIO::edf_findInHeader( char* header, const char* key )
31 {
32   char *value_ptr = strstr( header, key );
33
34   if (!value_ptr) return NULL;
35   /* an edf line is "key     = value ;" */
36   value_ptr = 1 + strchr( value_ptr + strlen(key), '=' );
37   while (isspace(*value_ptr) ) value_ptr++;
38   return value_ptr;
39 }
40
41 //--------------------------------------------------------------------
42 // Read Image Information
43 void rtk::EdfImageIO::ReadImageInformation()
44 {
45   int    k;
46   char * header = NULL;
47   int    header_size = 0;
48   char * p;
49   gzFile inp;
50
51   inp = gzopen(m_FileName.c_str(), "rb");
52   if (!inp)
53     itkGenericExceptionMacro(<< "Cannot open input file " << m_FileName);
54
55   // read header: it is a multiple of 512 B ending by "}\n"
56   while (header_size == 0 || strncmp(&header[header_size-2],"}\n",2) ) {
57     int header_size_prev = header_size;
58     header_size += 512;
59     if (!header)
60       header = (char*)malloc(header_size+1);
61     else
62       header = (char*)realloc(header, header_size+1);
63     header[header_size_prev] = 0; /* protection against empty file */
64     // fread(header+header_size_prev, 512, 1, fp);
65     k = gzread(inp, header+header_size_prev, 512);
66     if (k < 512) { /* protection against infinite loop */
67       gzclose(inp);
68       free(header);
69       itkGenericExceptionMacro(<< "Damaged EDF header of "
70                                << m_FileName
71                                << ": not multiple of 512 B.");
72       }
73     header[header_size] = 0; /* end of string: protection against strstr later
74                                on */
75     }
76
77   // parse the header
78   int   dim1 = -1, dim2 = -1, datalen = -1;
79   char *otherfile_name = 0; // this file, or another file with the data (EDF vs
80                             // EHF formats)
81   int   otherfile_skip = 0;
82
83   if ( (p = edf_findInHeader(header, "EDF_BinaryFileName") ) ) {
84     int plen = strcspn(p, " ;\n");
85     otherfile_name = (char*)realloc(otherfile_name, plen+1);
86     strncpy(otherfile_name, p, plen);
87     otherfile_name[plen] = '\0';
88     if ( (p = edf_findInHeader(header, "EDF_BinaryFilePosition") ) )
89       otherfile_skip = atoi(p);
90     }
91
92   if ( (p = edf_findInHeader(header, "Dim_1") ) )
93     dim1 = atoi(p);
94   if ( (p = edf_findInHeader(header, "Dim_2") ) )
95     dim2 = atoi(p);
96
97 //  int orig1 = -1, orig2 = -1;
98 //  if ((p = edf_findInHeader(header, "row_beg")))
99 //    orig1 = atoi(p);
100 //  if ((p = edf_findInHeader(header, "col_beg")))
101 //    orig2 = atoi(p);
102
103   static const struct table3 edf_datatype_table[] =
104     {
105           { "UnsignedByte",    U_CHAR_DATATYPE,  1 },
106           { "SignedByte",      CHAR_DATATYPE,    1 },
107           { "UnsignedShort",   U_SHORT_DATATYPE, 2 },
108           { "SignedShort",     SHORT_DATATYPE,   2 },
109           { "UnsignedInteger", U_INT_DATATYPE,   4 },
110           { "SignedInteger",   INT_DATATYPE,     4 },
111           { "UnsignedLong",    U_L_INT_DATATYPE, 4 },
112           { "SignedLong",      L_INT_DATATYPE,   4 },
113           { "FloatValue",      FLOAT_DATATYPE,   4 },
114           { "DoubleValue",     DOUBLE_DATATYPE,  8 },
115           { "Float",           FLOAT_DATATYPE,   4 }, // Float and FloatValue
116                                                       // are synonyms
117           { "Double",          DOUBLE_DATATYPE,  8 }, // Double and DoubleValue
118                                                       // are synonyms
119           { NULL, -1, -1 }
120     };
121   if ( (p = edf_findInHeader(header, "DataType") ) ) {
122     k = lookup_table3_nth(edf_datatype_table, p);
123     if (k < 0) { // unknown EDF DataType
124       gzclose(inp);
125       free(header);
126       itkGenericExceptionMacro( <<"Unknown EDF datatype \""
127                                 << p
128                                 << "\"");
129       }
130     datalen = edf_datatype_table[k].sajzof;
131     switch(k) {
132       case U_CHAR_DATATYPE:
133         SetComponentType(itk::ImageIOBase::UCHAR);
134         break;
135       case CHAR_DATATYPE:
136         SetComponentType(itk::ImageIOBase::CHAR);
137         break;
138       case U_SHORT_DATATYPE:
139         SetComponentType(itk::ImageIOBase::USHORT);
140         break;
141       case SHORT_DATATYPE:
142         SetComponentType(itk::ImageIOBase::SHORT);
143         break;
144       case U_INT_DATATYPE:
145         SetComponentType(itk::ImageIOBase::UINT);
146         break;
147       case INT_DATATYPE:
148         SetComponentType(itk::ImageIOBase::INT);
149         break;
150       case U_L_INT_DATATYPE:
151         SetComponentType(itk::ImageIOBase::ULONG);
152         break;
153       case L_INT_DATATYPE:
154         SetComponentType(itk::ImageIOBase::LONG);
155         break;
156       case FLOAT_DATATYPE:
157         SetComponentType(itk::ImageIOBase::FLOAT);
158         break;
159       case DOUBLE_DATATYPE:
160         SetComponentType(itk::ImageIOBase::DOUBLE);
161         break;
162       }
163     }
164
165   static const struct table edf_byteorder_table[] =
166     {
167           { "LowByteFirst",  LittleEndian }, /* little endian */
168           { "HighByteFirst", BigEndian },    /* big endian */
169           { NULL, -1 }
170     };
171
172   int byteorder = LittleEndian;
173   if ( (p = edf_findInHeader(header, "ByteOrder") ) ) {
174     k = lookup_table_nth(edf_byteorder_table, p);
175     if (k >= 0) {
176
177       byteorder = edf_byteorder_table[k].value;
178       if(byteorder==LittleEndian)
179         this->SetByteOrder(LittleEndian);
180       else
181         this->SetByteOrder(BigEndian);
182       }
183     } else
184     itkWarningMacro(<<"ByteOrder not specified in the header! Not swapping bytes (figure may not be correct).");
185   // Get and verify size of the data:
186   int datasize = dim1 * dim2 * datalen;
187   if ( (p = edf_findInHeader(header, "Size") ) ) {
188     int d = atoi(p);
189     if (d != datasize) {
190       itkWarningMacro(<< "Size " << datasize << " is not "
191                       << dim1 << 'x' << dim2 << "x" << datalen
192                       << " = " << d << ". Supposing the latter.");
193       }
194     }
195
196   // EHF files: binary data are in another file than the header file
197   m_BinaryFileName = m_FileName;
198   m_BinaryFileSkip = header_size;
199   if (otherfile_name) {
200     m_BinaryFileName = std::string(otherfile_name);
201     m_BinaryFileSkip = otherfile_skip;
202     }
203
204   double spacing = 1.;
205   if ( (p = edf_findInHeader(header, "optic_used") ) )
206     spacing = atof(p);
207
208   free(header);
209   gzclose(inp);
210
211   SetNumberOfDimensions(2);
212   SetDimensions(0, dim1);
213   SetDimensions(1, dim2);
214   SetSpacing(0, spacing);
215   SetSpacing(1, spacing);
216   SetOrigin(0, 0.);
217   SetOrigin(1, 0.);
218 } ////
219
220 //--------------------------------------------------------------------
221 // Read Image Information
222 bool rtk::EdfImageIO::CanReadFile(const char* FileNameToRead)
223 {
224   std::string                  filename(FileNameToRead);
225   const std::string::size_type it = filename.find_last_of( "." );
226   std::string                  fileExt( filename, it+1, filename.length() );
227
228   if (fileExt != std::string("edf") ) return false;
229   return true;
230 } ////
231
232 //--------------------------------------------------------------------
233 // Read Image Content
234 void rtk::EdfImageIO::Read(void * buffer)
235 {
236   gzFile inp;
237
238   inp = gzopen(m_BinaryFileName.c_str(), "rb");
239   if (!inp)
240     itkGenericExceptionMacro(<< "Cannot open file \"" << m_FileName << "\"");
241   gzseek(inp, m_BinaryFileSkip, SEEK_SET);
242
243   // read the data (image)
244   long numberOfBytesToBeRead = GetComponentSize();
245   for(unsigned int i=0; i<GetNumberOfDimensions(); i++) numberOfBytesToBeRead *= GetDimensions(i);
246
247   if (numberOfBytesToBeRead != gzread(inp, buffer, numberOfBytesToBeRead) )
248     itkGenericExceptionMacro(<< "The image " << m_BinaryFileName << " cannot be read completely.");
249
250   gzclose(inp);
251
252   // Adapted from itkRawImageIO
253     {
254     using namespace itk;
255     // Swap bytes if necessary
256     if itkReadRawBytesAfterSwappingMacro( unsigned short, USHORT )
257     else if itkReadRawBytesAfterSwappingMacro( short, SHORT )
258     else if itkReadRawBytesAfterSwappingMacro( char, CHAR )
259     else if itkReadRawBytesAfterSwappingMacro( unsigned char, UCHAR )
260     else if itkReadRawBytesAfterSwappingMacro( unsigned int, UINT )
261     else if itkReadRawBytesAfterSwappingMacro( int, INT )
262     else if itkReadRawBytesAfterSwappingMacro( unsigned int, ULONG )
263     else if itkReadRawBytesAfterSwappingMacro( int, LONG )
264     else if itkReadRawBytesAfterSwappingMacro( float, FLOAT )
265     else if itkReadRawBytesAfterSwappingMacro( double, DOUBLE );
266     }
267 }
268
269 //--------------------------------------------------------------------
270 // Write Image Information
271 void rtk::EdfImageIO::WriteImageInformation(bool keepOfStream)
272 {
273 }
274
275 //--------------------------------------------------------------------
276 // Write Image Information
277 bool rtk::EdfImageIO::CanWriteFile(const char* FileNameToWrite)
278 {
279   return false;
280 }
281
282 //--------------------------------------------------------------------
283 // Write Image
284 void rtk::EdfImageIO::Write(const void * buffer)
285 {
286 } ////