def read_image_data(self):
if self.imdtype == 'not_implemented':
raise AttributeError, "image data type: %s" % self.imdtype
if ('packed' in self.imdtype):
return self.read_packed_complex()
elif ('rgb' in self.imdtype):
return self.read_rgb()
else:
data = read_data_array(self.filename, self.imbytes,
self.byte_offset, self.imdtype)
imsize = self.imsize.tolist()
if self.order == 'F':
if self.record_by == 'spectrum':
swapelem(imsize, 0, 1)
data = data.reshape(imsize, order = self.order)
data = np.swapaxes(data, 0, 1).copy()
elif self.record_by == 'image':
data = data.reshape(imsize, order = 'C')
elif self.order == 'C':
if self.record_by == 'spectrum':
data = data.reshape(np.roll(self.imsize,1), order = self.order)
data = np.rollaxis(data, 0, self.dim).copy()
elif self.record_by == 'image':
data = data.reshape(self.imsize, order = self.order)
return data
def to_spectrum(self):
from hyperspy.signals.spectrum import Spectrum
dic = self._get_signal_dict()
dic['mapped_parameters']['record_by'] = 'spectrum'
dic['data'] = np.swapaxes(dic['data'], 0, -1)
utils_varia.swapelem(dic['axes'], 0, -1)
dic['axes'][0]['index_in_array'] = 0
dic['axes'][-1]['index_in_array'] = len(dic['axes']) - 1
return Spectrum(dic)
def to_spectrum(self):
from hyperspy.signals.spectrum import Spectrum
dic = self._get_signal_dict()
dic['mapped_parameters']['record_by'] = 'spectrum'
dic['data'] = np.swapaxes(dic['data'], 0, -1)
utils_varia.swapelem(dic['axes'],0,-1)
dic['axes'][0]['index_in_array'] = 0
dic['axes'][-1]['index_in_array'] = len(dic['axes']) - 1
return Spectrum(dic)
def open(self):
self.data_dict = open_dm3(self.filename)
byte_order = self.data_dict.ls(DM3ImageFile.endian)[1][1]
if byte_order == 1:
self.byte_order = 'little'
elif byte_order == 0:
self.byte_order = 'big'
else:
raise ByteOrderError, byte_order
self.endian = self.byte_order
self.data_dict.cd(DM3ImageFile.imlistdir) # enter ImageList
image_id = [im for im in self.data_dict.ls() if ('Group' in im
and im != 'Group0')]
#Group0 is THUMBNAIL and GroupX (X !=0) is IMAGE
image_id.sort()
if len(image_id) > 1 or self.data_id == 0 and self.output_level>1:
print 'File "%s" contains %i images:' % (self.filename,
len(image_id))
print
print 'ID | Name'
print ' | '
for i in image_id:
imid, imname = (image_id.index(i) + 1,
self.data_dict.ls([i,] + DM3ImageFile.imname)[1][1])
print ' ', imid, '|', imname
print '_____________'
if self.data_id == 0:
print 'Image ID "%i" is not valid.' % self.data_id
print 'Please specify a valid image ID'
return None
try:
im = image_id[self.data_id - 1]
name = self.data_dict.ls([im,] + DM3ImageFile.imname)
if name:
self.name = self.data_dict.ls([im,] + DM3ImageFile.imname)[1][1]
else:
self.name = ""
#~ if self.output_level>1:
#~ print 'Loading image "%s" (ID: %i) from file %s'% (self.name,
#~ self.data_id,
#~ self.filename)
except IndexError:
raise ImageIDError(self.data_id)
self.data_dict.cd(image_id[self.data_id - 1]) # enter Group[ID]
try:
self.exposure = self.data_dict.ls(DM3ImageFile.dwelltime)[1][1]
except:
self.exposure = None
try:
self.vsm = self.data_dict.ls(DM3ImageFile.vsm)[1][1]
except:
self.vsm = None
self.old_code_tags = parseDM3(self.filename)
self.SI_format = None
self.signal = ""
for tag, value in self.old_code_tags.iteritems():
if 'Format' in tag and 'Spectrum image' in str(value):
self.SI_format = value
if 'Signal' in tag and 'EELS' in str(value):
self.signal = value
# try:
# self.SI_format = self.data_dict.ls(DM3ImageFile.Gatan_EELS_SI_dir+['Meta Data','Format'])[1][1]
# except:
# try:
# self.SI_format = self.data_dict.ls(DM3ImageFile.Gatan_EFTEM_SI_dir+['Meta Data','Format'])[1][1]
# except:
# try:
# # Fall-back for images that have been manually converted to SIs
# self.SI_format = self.data_dict.ls(DM3ImageFile.imtagsdir+['Meta Data','Format'])[1][1]
# except:
# self.SI_format = None
# try:
# self.signal = self.data_dict.ls(DM3ImageFile.Gatan_EELS_SI_dir+['Meta Data','Signal'])[1][1]
# except:
# try:
# self.signal=self.data_dict.ls(DM3ImageFile.Gatan_EFTEM_SI_dir+['Meta Data','Format'])[1][1]
# except:
# try:
# # Fall-back for images that have been manually converted to SIs
# self.signal = self.data_dict.ls(DM3ImageFile.imtagsdir+['Meta Data','Signal'])[1]
# except:
# self.signal = None
self.data_dict.cd()
imdtype = self.data_dict.ls(DM3ImageFile.imdtype)[1][1]
self.imdtype = DM3ImageFile.imdtype_dict[imdtype]
self.byte_offset = self.data_dict.ls(DM3ImageFile.im)[1][0]
self.imbytes = self.data_dict.ls(DM3ImageFile.im)[1][1]
self.pixel_depth = self.data_dict.ls(DM3ImageFile.pixdepth)[1][1]
sizes = []
for i in self.data_dict.ls(DM3ImageFile.calibdir):
if 'Data' in i:
try:
int(i[-1])
sizes.append((i,
self.data_dict.ls(DM3ImageFile.calibdir
+ [i,])))
except:
pass
sizes.sort()
# swapelem(sizes, 0, 1)
origins = []
for i in self.data_dict.ls(DM3ImageFile.brightdir):
if 'Group' in i:
origins.append((i,
self.data_dict.ls(DM3ImageFile.brightdir
+ [i,]
+ DM3ImageFile.origin)))
origins.sort()
# swapelem(origins, 0, 1)
scales = []
for i in self.data_dict.ls(DM3ImageFile.brightdir):
if 'Group' in i:
scales.append((i,
self.data_dict.ls(DM3ImageFile.brightdir
+ [i,]
+ DM3ImageFile.scale)))
scales.sort()
# swapelem(scales, 0, 1)
units = []
for i in self.data_dict.ls(DM3ImageFile.brightdir):
if 'Group' in i:
units.append((i,
self.data_dict.ls(DM3ImageFile.brightdir
+ [i,]
+ DM3ImageFile.units)))
units.sort()
# swapelem(units, 0, 1)
# Determine the dimensions of the data
self.dim = 0
for i in xrange(len(sizes)):
if sizes[i][1][1][1] > 1:
self.dim += 1
if units[i][1][1][1] in ('eV', 'keV'):
eV_in = True
else:
eV_in = False
# Try to guess the order if not given
# (there must be a better way!!)
if self.order is None:
if self.SI_format == 'Spectrum image':
self.order = 'F'
else:
self.order = 'C'
# Try to guess the record_by if not given
# (there must be a better way!!)
if self.record_by is None:
if (self.dim > 1 and eV_in) or self.dim == 1 or \
self.signal == 'EELS' or self.SI_format == 'Spectrum image':
self.record_by = 'spectrum'
else:
self.record_by = 'image'
names = ['X', 'Y', 'Z'] if self.record_by == 'image' \
else ['X', 'Y', 'Energy']
to_swap = [sizes, origins, scales, units, names]
for l in to_swap:
if self.record_by == 'spectrum':
swapelem(l,0,1)
elif self.record_by == 'image':
l.reverse()
dimensions = [(
sizes[i][1][1][1],
origins[i][1][1][1],
scales[i][1][1][1],
units[i][1][1][1],
names[i])
for i in xrange(len(sizes))]
# create a structured array:
# self.dimensions['sizes'] -> integer
# self.dimensions['origins'] -> float
# self.dimensions['scales'] -> float
# self.dimensions['units'] -> string
self.dimensions = np.asarray(dimensions,
dtype={'names':['sizes',
'origins',
'scales',
'units',
'names',],
'formats':['i8',
'f4',
'f4',
'U8',
'U8',]})
self.imsize = self.dimensions['sizes']
self.units = self.dimensions['units']
br_orig = self.data_dict.ls(DM3ImageFile.brightdir
+ DM3ImageFile.origin)[1][1]
br_scale = self.data_dict.ls(DM3ImageFile.brightdir
+ DM3ImageFile.scale)[1][1]
br_units = self.data_dict.ls(DM3ImageFile.brightdir
+ DM3ImageFile.units)[1][1]
self.brightness = np.array((br_orig, br_scale, br_units))
# self.data = self.read_image_data()
# try:
self.data = self.read_image_data()
# except AttributeError:
# print('Error. Could not read data.')
# self.data = 'UNAVAILABLE'
# return None
# remove axes whose dimension is 1, they are useless:
while 1 in self.data.shape:
i = self.data.shape.index(1)
self.dimensions = np.delete(self.dimensions, i)
self.imsize = np.delete(self.imsize, i)
self.data = self.data.squeeze()
d = len(self.dimensions)
if d == 0: # could also implement a 'mode' dictionary...
raise ImageModeError(d)
else:
self.mode += str(d) + 'D'
