Source Code for Module fabio.dm3image

  1  """ 
  2  Authors: Henning O. Sorensen & Erik Knudsen 
  3           Center for Fundamental Research: Metal Structures in Four Dimensions 
  4           Risoe National Laboratory 
  5           Frederiksborgvej 399 
  6           DK-4000 Roskilde 
  7           email:erik.knudsen@risoe.dk 
  8   
  9          + Jon Wright, ESRF 
 10  """ 
 11   
 12  import numpy as n, logging 
 13   
 14  from fabioimage import fabioimage 
 15   
 16  DATA_TYPES = {  2     :  n.int16, 
 17                  4     :  n.uint16, 
 18                  3     :  n.int32, 
 19                  5     :  n.uint32, 
 20                  6     :  n.float32, 
 21                  7     :  n.float, 
 22                  8     :  n.int8, 
 23                  9     :  None, 
 24                  10    :  None, 
 25                  15    :  'Struct', 
 26                  18    :  None, 
 27                  20    :  None 
 28                  } 
 29   
 30  DATA_BYTES = {  2     :  2, 
 31                  4     :  2, 
 32                  3     :  4, 
 33                  5     :  4, 
 34                  6     :  4, 
 35                  7     :  8, 
 36                  8     :  1, 
 37                  9     :  None, 
 38                  10    :  None, 
 39                  15    :  'Struct', 
 40                  18    :  None, 
 41                  20    :  None 
 42                  } 
 43   
 44   
 45   
 46 -class dm3image(fabioimage): 
 47      """ Read and try to write the dm3 data format """ 
 48   
 49   
 50 -    def _readheader(self): 
 51          self.infile.seek(0) 
 52          file_format = self.readbytes(4, n.uint32)[0] # should be 3 
 53          assert file_format == 3, 'Wrong file type ' 
 54          self.bytes_in_file = self.readbytes(4, n.uint32)[0] 
 55          self.byte_order = self.readbytes(4, n.uint32)[0] # 0 = big, 1= little 
 56          print 'read dm3 file - file format ', file_format 
 57          print 'Bytes in file : ' , self.bytes_in_file 
 58          print 'Byte order :', self.byte_order, '  - 0 = bigEndian , 1 = littleEndian' 
 59   
 60          if self.byte_order == 0: 
 61              self.swap = True 
 62          elif self.byte_order == 1: 
 63              self.swap = False 
 64          else: 
 65              raise ValueError 
 66   
 67 -    def read(self, fname): 
 68          self.header = {} 
 69          self.resetvals() 
 70          self.infile = self._open(fname, "rb") 
 71          self._readheader() 
 72          self.go_on = True 
 73          print self.go_on 
 74          while self.go_on: 
 75              self.read_tag_group() 
 76              self.read_tag_entry() 
 77              if self.infile.tell() > self.bytes_in_file: break 
 78   
 79              while self.tag_is_data == 21: 
 80                  self.read_tag_entry() 
 81                  if self.infile.tell() > self.bytes_in_file: 
 82                      self.go_on = False 
 83   
 84          (dim1_raw, dim2_raw) = self.header['Active Size (pixels)'].split() 
 85          (dim1_raw, dim2_raw) = (eval(dim1_raw), eval(dim2_raw)) 
 86          (dim1_binning, dim2_binning) = self.header['Binning'].split() 
 87          (dim1_binning, dim2_binning) = (eval(dim1_binning), eval(dim2_binning)) 
 88          self.dim1 = dim1_raw / dim1_binning 
 89          self.dim2 = dim2_raw / dim2_binning 
 90          #print dim1,dim2 
 91          if self.header.has_key('Data'): 
 92              self.data = self.header['Data'].reshape(self.dim1, self.dim2) 
 93   
 94 -    def readbytes(self, bytes_to_read, format, swap=True): 
 95          raw = self.infile.read(bytes_to_read) 
 96          if format != None: 
 97              data = n.fromstring(raw, format) 
 98          else: 
 99              data = raw 
100          if swap: 
101              data = data.byteswap() 
102          return data 
103   
104   
105   
106 -    def read_tag_group(self): 
107   
108          self.grouptag_is_sorted = self.readbytes(1, n.uint8)[0] 
109          self.grouptag_is_open = self.readbytes(1, n.uint8)[0] 
110          self.grouptag_no_tags = self.readbytes(4, n.uint32)[0] 
111          #print 'TagGroup is sorted? ',self.grouptag_is_sorted 
112          #print 'TagGroup is open? ',self.grouptag_is_open 
113          #print 'no of tags in TagGroup', self.grouptag_no_tags 
114   
115 -    def read_tag_entry(self): 
116   
117          self.tag_is_data = self.readbytes(1, n.uint8)[0] 
118          self.tag_label_length = self.readbytes(2, n.uint16)[0] 
119          #print 'does Tag have data ?' , self.tag_is_data, ' -  20 = Tag group , 21 = data ' 
120          #print 'length of tag_label ', self.tag_label_length 
121          if self.tag_label_length != 0: 
122              tag_label = self.infile.read(self.tag_label_length) 
123          else: 
124              tag_label = None 
125   
126          if self.tag_is_data == 21: 
127              # This is data 
128              self.header[tag_label] = self.read_tag_type() 
129              #print self.header[tag_label] 
130   
131   
132 -    def read_tag_type(self): 
133          if self.infile.read(4) != '%%%%': 
134              raise IOError 
135          self.tag_data_type = self.readbytes(4, n.uint32)[0] 
136          #print 'data is of type :', self.tag_data_type , '  - 1 = simple, 2= string, 3 = array, >3 structs' 
137          self.tag_encoded_type = self.readbytes(4, n.uint32)[0] 
138          # print 'encode type: ', self.tag_encoded_type, DATA_TYPES[ self.tag_encoded_type]  
139          if self.tag_data_type == 1: 
140              # simple type 
141              return self.readbytes(DATA_BYTES[ self.tag_encoded_type], 
142                                    DATA_TYPES[ self.tag_encoded_type], 
143                                    swap=self.swap)[0] 
144          # are the data stored in a simple array? 
145          if self.tag_encoded_type == 20 and self.tag_data_type == 3 : 
146              self.data_type = self.readbytes(4, n.uint32)[0] 
147              self.no_data_elements = self.readbytes(4, n.uint32)[0] 
148              if self.data_type == 10: 
149                  #print 'skip bytes', self.no_data_elements 
150                  dump = self.infile.read(self.no_data_elements) 
151                  return None 
152   
153              # print 'Data are stored as a simple a array -' 
154              # print '%i data elemets stored as ' %self.no_data_elements, self.data_type 
155              read_no_bytes = DATA_BYTES[self.data_type] * self.no_data_elements 
156              format = DATA_TYPES[self.data_type] 
157              return self.readbytes(read_no_bytes, format, swap=self.swap) 
158   
159          # are the data stored in a complex array ? 
160          # print 'tag_type + data_type', self.tag_encoded_type,self.tag_data_type 
161   
162          #print self.tag_encoded_type , self.tag_data_type  
163          if self.tag_encoded_type == 20 and self.tag_data_type > 3 : 
164              self.tag_encoded_type = self.readbytes(4, n.uint32)[0] 
165              #print 'found array - new tag_encoded_type', self.tag_encoded_type 
166              if self.tag_encoded_type == 15:            # struct type 
167                   ###type = self.readbytes(4,n.int32) 
168                  struct_name_length = self.readbytes(4, n.int32)[0] 
169                  struct_number_fields = self.readbytes(4, n.int32)[0] 
170                  #print 'struct - name_length, number_field',  struct_name_length,struct_number_fields 
171                  #print self.infile.read(struct_name_length) 
172                  field_info = [] 
173                  for i in range(struct_number_fields): 
174                      field_info.append([self.readbytes(4, n.int32)[0], self.readbytes(4, n.int32)[0]]) 
175                  #print field_info 
176                  self.no_data_elements = self.readbytes(4, n.int32)[0] 
177                  #print '%i data elemets stored as ' %self.no_data_elements 
178                  bytes_in_struct = 0 
179                  for i in range(struct_number_fields): 
180                      bytes_in_struct += DATA_BYTES[field_info[i][1]] 
181                  #print 'skip bytes', self.no_data_elements* bytes_in_struct 
182                  dump = self.infile.read(self.no_data_elements * bytes_in_struct) 
183                  return None 
184   
185   
186          if self.tag_encoded_type == 15:            # struct type 
187              ###type = self.readbytes(4,n.int32) 
188              struct_name_length = self.readbytes(4, n.int32)[0] 
189              struct_number_fields = self.readbytes(4, n.int32)[0] 
190              #print 'struct - name_length, number_field',  struct_name_length,struct_number_fields 
191              #print self.infile.read(struct_name_length) 
192              field_info = [] 
193              for i in range(struct_number_fields): 
194                  field_info.append([self.readbytes(4, n.int32)[0], self.readbytes(4, n.int32)[0]]) 
195              #print field_info 
196              field_data = '' 
197              for i in range(struct_number_fields): 
198                  #print type(i) 
199                  field_data = field_data + self.readbytes(field_info[i][0], None, swap=False) + ' ' 
200                  field_data = field_data + '%i  ' % self.readbytes(DATA_BYTES[field_info[i][1]], 
201                                                                   DATA_TYPES[field_info[i][1]], 
202                                                                   swap=self.swap)[0] 
203              return field_data 
204   
205 -    def read_data(self): 
206          self.encoded_datatype = n.fromstring(self.infile.read(4), n.uint32).byteswap() 
207