def testExportRead(self):
"""
Checks that we can read back an image and a thumbnail
"""
# create 2 simple greyscale images
sizes = [(512, 256), (500, 400)
] # different sizes to ensure different acquisitions
dtype = numpy.dtype("uint16")
white = (12, 52) # non symmetric position
ldata = []
num = 2
# TODO: check support for combining channels when same data shape
for i in range(num):
a = model.DataArray(numpy.zeros(sizes[i][::-1], dtype))
a[white[::-1]] = 1027
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 0] += 255 # red
blue = (12, 22) # non symmetric position
thumbnail[blue[::-1]] = [0, 0, 255]
thumbnail.metadata[model.MD_POS] = (0.1, -2)
thumbnail.metadata[model.MD_PIXEL_SIZE] = (13e-6, 13e-6)
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), num)
for i, im in enumerate(rdata):
subim = im[0, 0, 0] # remove C,T,Z dimensions
self.assertEqual(subim.shape, sizes[i][-1::-1])
self.assertEqual(subim[white[-1:-3:-1]], ldata[i][white[-1:-3:-1]])
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [255, 0, 0])
self.assertEqual(im[blue[::-1]].tolist(), [0, 0, 255])
self.assertAlmostEqual(im.metadata[model.MD_POS],
thumbnail.metadata[model.MD_POS])
def testExportRead(self):
"""
Checks that we can read back an image and a thumbnail
"""
# create 2 simple greyscale images
sizes = [(512, 256), (500, 400)] # different sizes to ensure different acquisitions
dtype = numpy.dtype("uint16")
white = (12, 52) # non symmetric position
ldata = []
num = 2
# TODO: check support for combining channels when same data shape
for i in range(num):
a = model.DataArray(numpy.zeros(sizes[i][::-1], dtype))
a[white[::-1]] = 1027
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 0] += 255 # red
blue = (12, 22) # non symmetric position
thumbnail[blue[::-1]] = [0, 0, 255]
thumbnail.metadata[model.MD_POS] = (0.1, -2)
thumbnail.metadata[model.MD_PIXEL_SIZE] = (13e-6, 13e-6)
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), num)
for i, im in enumerate(rdata):
subim = im[0, 0, 0] # remove C,T,Z dimensions
self.assertEqual(subim.shape, sizes[i][-1::-1])
self.assertEqual(subim[white[-1:-3:-1]], ldata[i][white[-1:-3:-1]])
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [255, 0, 0])
self.assertEqual(im[blue[::-1]].tolist(), [0, 0, 255])
self.assertAlmostEqual(im.metadata[model.MD_POS], thumbnail.metadata[model.MD_POS])
def testReadMDFluo(self):
"""
Checks that we can read back the metadata of a fluoresence image
The OME-TIFF file will contain just one big array, but three arrays
should be read back with the right data.
"""
metadata = [
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "brightfield",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_IN_WL: (400e-9, 630e-9), # m
model.MD_OUT_WL: (400e-9, 630e-9), # m
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "blue dye",
model.MD_ACQ_DATE: time.time() + 10,
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_IN_WL: (500e-9, 520e-9), # m
model.MD_OUT_WL: (600e-9, 630e-9), # m
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "green dye",
model.MD_ACQ_DATE: time.time() + 20,
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -3e-3), # m
model.MD_EXP_TIME: 1, # s
model.MD_IN_WL: (600e-9, 620e-9), # m
model.MD_OUT_WL: (620e-9, 650e-9), # m
},
]
# create 3 greyscale images of same size
size = (512, 256)
dtype = numpy.dtype("uint16")
ldata = []
for i, md in enumerate(metadata):
a = model.DataArray(numpy.zeros(size[::-1], dtype), md)
a[i, i] = i # "watermark" it
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (size[1] // 8, size[0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
# TODO: rdata and ldata don't have to be in the same order
for i, im in enumerate(rdata):
md = metadata[i]
self.assertEqual(im.metadata[model.MD_DESCRIPTION],
md[model.MD_DESCRIPTION])
self.assertAlmostEqual(im.metadata[model.MD_POS][0],
md[model.MD_POS][0])
self.assertAlmostEqual(im.metadata[model.MD_POS][1],
md[model.MD_POS][1])
self.assertAlmostEqual(im.metadata[model.MD_PIXEL_SIZE][0],
md[model.MD_PIXEL_SIZE][0])
self.assertAlmostEqual(im.metadata[model.MD_PIXEL_SIZE][1],
md[model.MD_PIXEL_SIZE][1])
iwl = im.metadata[model.MD_IN_WL] # nm
self.assertTrue((md[model.MD_IN_WL][0] <= iwl[0]
and iwl[1] <= md[model.MD_IN_WL][1]))
owl = im.metadata[model.MD_OUT_WL] # nm
self.assertTrue((md[model.MD_OUT_WL][0] <= owl[0]
and owl[1] <= md[model.MD_OUT_WL][1]))
# SVI HDF5 only records one acq time per T dimension
# so only check for the first channel
if i == 0:
self.assertAlmostEqual(im.metadata[model.MD_ACQ_DATE],
md[model.MD_ACQ_DATE],
delta=1)
# SVI HDF5 doesn't this metadata:
# self.assertEqual(im.metadata[model.MD_BPP], md[model.MD_BPP])
# self.assertEqual(im.metadata[model.MD_BINNING], md[model.MD_BINNING])
self.assertEqual(im.metadata[model.MD_EXP_TIME],
md[model.MD_EXP_TIME])
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDAR(self):
"""
Checks that we can read back the metadata of an Angular Resolved image
"""
metadata = [
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "sem survey",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 2), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake ccd",
model.MD_DESCRIPTION: "AR",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_SENSOR_PIXEL_SIZE: (13e-6, 13e-6), # m/px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1.2e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_AR_POLE: (253.1, 65.1),
model.MD_LENS_MAG: 60, # ratio
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake ccd",
model.MD_DESCRIPTION: "AR",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_SENSOR_PIXEL_SIZE: (13e-6, 13e-6), # m/px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_AR_POLE: (253.1, 65.1),
model.MD_LENS_MAG: 60, # ratio
},
]
# create 2 simple greyscale images
sizes = [(512, 256), (500, 400), (500, 400)
] # different sizes to ensure different acquisitions
dtype = numpy.dtype("uint16")
ldata = []
for s, md in zip(sizes, metadata):
a = model.DataArray(numpy.zeros(s[::-1], dtype), md)
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for im, md in zip(rdata, metadata):
self.assertEqual(im.metadata[model.MD_DESCRIPTION],
md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE],
md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE],
md[model.MD_ACQ_DATE])
if model.MD_AR_POLE in md:
self.assertEqual(im.metadata[model.MD_AR_POLE],
md[model.MD_AR_POLE])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG],
md[model.MD_LENS_MAG])
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDSpec(self):
"""
Checks that we can read back the metadata of an image
"""
metadata = [
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "test",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 2), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake spec",
model.MD_DESCRIPTION: "test3d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_WL_POLYNOMIAL: [500e-9,
1e-9], # m, m/px: wl polynomial
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
},
]
# create 2 simple greyscale images
sizes = [(512, 256), (500, 400, 1, 1, 220)
] # different sizes to ensure different acquisitions
dtype = numpy.dtype("uint8")
ldata = []
for i, s in enumerate(sizes):
a = model.DataArray(numpy.zeros(s[::-1], dtype), metadata[i])
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for i, im in enumerate(rdata):
md = metadata[i]
self.assertEqual(im.metadata[model.MD_DESCRIPTION],
md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE],
md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE],
md[model.MD_ACQ_DATE])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG],
md[model.MD_LENS_MAG])
# None of the images are using light => no MD_IN_WL
self.assertFalse(
model.MD_IN_WL in im.metadata,
"Reporting excitation wavelength while there is none")
if model.MD_WL_POLYNOMIAL in md:
pn = md[model.MD_WL_POLYNOMIAL]
# 2 formats possible
if model.MD_WL_LIST in im.metadata:
l = ldata[i].shape[0]
npn = polynomial.Polynomial(pn,
domain=[0, l - 1],
window=[0, l - 1])
wl = npn.linspace(l)[1]
self.assertEqual(im.metadata[model.MD_WL_LIST], wl)
else:
self.assertEqual(im.metadata[model.MD_WL_POLYNOMIAL], pn)
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDFluo(self):
"""
Checks that we can read back the metadata of a fluoresence image
The HDF5 file will contain just one big array, but three arrays
should be read back with the right data. With the rotation, the
last array should be kept separate.
"""
# SVI HDF5 only records one acq time per T dimension
# so only record and save one time
acq_date = time.time()
metadata = [{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "brightfield",
model.MD_ACQ_DATE: acq_date,
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_IN_WL: (400e-9, 630e-9), # m
model.MD_OUT_WL: (400e-9, 630e-9), # m
# correction metadata
model.MD_POS_COR: (-1e-6, 3e-6), # m
model.MD_PIXEL_SIZE_COR: (1.2, 1.2),
model.MD_ROTATION_COR: 6.27, # rad
model.MD_SHEAR_COR: 0.01,
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "blue dye",
model.MD_ACQ_DATE: acq_date,
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_IN_WL: (500e-9, 520e-9), # m
model.MD_OUT_WL: (650e-9, 660e-9, 675e-9, 680e-9, 686e-9), # m
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "green dye",
model.MD_ACQ_DATE: acq_date,
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (13.7e-3, -30e-3), # m
model.MD_EXP_TIME: 1, # s
model.MD_IN_WL: (600e-9, 620e-9), # m
model.MD_OUT_WL: (620e-9, 650e-9), # m
model.MD_ROTATION: 0.1, # rad
model.MD_SHEAR: 0,
model.MD_BASELINE: 200
},
]
# create 3 greyscale images of same size
size = (512, 256)
dtype = numpy.dtype("uint16")
ldata = []
for i, md in enumerate(metadata):
a = model.DataArray(numpy.zeros(size[::-1], dtype), md)
a[i, i] = i # "watermark" it
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (size[1] // 8, size[0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
# TODO: rdata and ldata don't have to be in the same order
for i, im in enumerate(rdata):
md = metadata[i].copy()
img.mergeMetadata(md)
self.assertEqual(im.metadata[model.MD_DESCRIPTION], md[model.MD_DESCRIPTION])
self.assertAlmostEqual(im.metadata[model.MD_POS][0], md[model.MD_POS][0])
self.assertAlmostEqual(im.metadata[model.MD_POS][1], md[model.MD_POS][1])
self.assertAlmostEqual(im.metadata[model.MD_PIXEL_SIZE][0], md[model.MD_PIXEL_SIZE][0])
self.assertAlmostEqual(im.metadata[model.MD_PIXEL_SIZE][1], md[model.MD_PIXEL_SIZE][1])
iwl = im.metadata[model.MD_IN_WL] # nm
self.assertTrue((md[model.MD_IN_WL][0] <= iwl[0] and
iwl[1] <= md[model.MD_IN_WL][-1]))
owl = im.metadata[model.MD_OUT_WL] # nm
self.assertTrue((md[model.MD_OUT_WL][0] <= owl[0] and
owl[1] <= md[model.MD_OUT_WL][-1]))
self.assertAlmostEqual(im.metadata[model.MD_ACQ_DATE], acq_date, delta=1)
# SVI HDF5 doesn't this metadata:
# self.assertEqual(im.metadata[model.MD_BPP], md[model.MD_BPP])
# self.assertEqual(im.metadata[model.MD_BINNING], md[model.MD_BINNING])
self.assertEqual(im.metadata[model.MD_EXP_TIME], md[model.MD_EXP_TIME])
self.assertEqual(im.metadata.get(model.MD_ROTATION, 0), md.get(model.MD_ROTATION, 0))
self.assertEqual(im.metadata.get(model.MD_BASELINE, 0), md.get(model.MD_BASELINE, 0))
self.assertEqual(im.metadata.get(model.MD_SHEAR, 0), md.get(model.MD_SHEAR, 0))
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDAR(self):
"""
Checks that we can read back the metadata of an Angular Resolved image
"""
metadata = [{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "sem survey",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
model.MD_EBEAM_VOLTAGE: 10000, # V
model.MD_EBEAM_CURRENT: 2.6, # A
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake ccd",
model.MD_DESCRIPTION: "AR",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_SENSOR_PIXEL_SIZE: (13e-6, 13e-6), # m/px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1.2e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_AR_POLE: (253.1, 65.1),
model.MD_AR_XMAX: 12e-3,
model.MD_AR_HOLE_DIAMETER: 0.6e-3,
model.MD_AR_FOCUS_DISTANCE: 0.5e-3,
model.MD_AR_PARABOLA_F: 2e-3,
model.MD_LENS_MAG: 60, # ratio
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake ccd",
model.MD_DESCRIPTION: "AR",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_SENSOR_PIXEL_SIZE: (13e-6, 13e-6), # m/px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_AR_POLE: (253.1, 65.1),
model.MD_AR_XMAX: 12e-3,
model.MD_AR_HOLE_DIAMETER: 0.6e-3,
model.MD_AR_FOCUS_DISTANCE: 0.5e-3,
model.MD_AR_PARABOLA_F: 2e-3,
model.MD_LENS_MAG: 60, # ratio
},
]
# create 2 simple greyscale images
sizes = [(512, 256), (500, 400), (500, 400)] # different sizes to ensure different acquisitions
dtype = numpy.dtype("uint16")
ldata = []
for s, md in zip(sizes, metadata):
a = model.DataArray(numpy.zeros(s[::-1], dtype), md)
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for im, md in zip(rdata, metadata):
self.assertEqual(im.metadata[model.MD_DESCRIPTION], md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE], md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE], md[model.MD_ACQ_DATE])
if model.MD_AR_POLE in md:
self.assertEqual(im.metadata[model.MD_AR_POLE], md[model.MD_AR_POLE])
if model.MD_AR_XMAX in md:
self.assertEqual(im.metadata[model.MD_AR_XMAX], md[model.MD_AR_XMAX])
if model.MD_AR_HOLE_DIAMETER in md:
self.assertEqual(im.metadata[model.MD_AR_HOLE_DIAMETER], md[model.MD_AR_HOLE_DIAMETER])
if model.MD_AR_FOCUS_DISTANCE in md:
self.assertEqual(im.metadata[model.MD_AR_FOCUS_DISTANCE], md[model.MD_AR_FOCUS_DISTANCE])
if model.MD_AR_PARABOLA_F in md:
self.assertEqual(im.metadata[model.MD_AR_PARABOLA_F], md[model.MD_AR_PARABOLA_F])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG], md[model.MD_LENS_MAG])
if model.MD_EBEAM_CURRENT in md:
self.assertEqual(im.metadata[model.MD_EBEAM_CURRENT], md[model.MD_EBEAM_CURRENT])
if model.MD_EBEAM_VOLTAGE in md:
self.assertEqual(im.metadata[model.MD_EBEAM_VOLTAGE], md[model.MD_EBEAM_VOLTAGE])
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDSpec(self):
"""
Checks that we can read back the metadata of an image
"""
sizes = [(512, 256), (500, 400, 1, 1, 220)] # different sizes to ensure different acquisitions
metadata = [{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "test",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 2), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake spec",
model.MD_DESCRIPTION: "test3d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-5), # m/px
#model.MD_WL_POLYNOMIAL: [500e-9, 1e-9], # m, m/px: wl polynomial
model.MD_WL_LIST: [500e-9 + i * 1e-9 for i in range(sizes[1][-1])],
model.MD_OUT_WL: "pass-through",
model.MD_POS: (1e-3, -30e-3), # m
model.MD_EXP_TIME: 1.2, # s
},
]
# create 2 simple greyscale images
dtype = numpy.dtype("uint8")
ldata = []
for i, s in enumerate(sizes):
a = model.DataArray(numpy.zeros(s[::-1], dtype), metadata[i])
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (sizes[0][1] // 8, sizes[0][0] // 8, 3)
tdtype = numpy.uint8
thumbnail = model.DataArray(numpy.zeros(tshape, tdtype))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for i, im in enumerate(rdata):
md = metadata[i]
self.assertEqual(im.metadata[model.MD_DESCRIPTION], md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE], md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE], md[model.MD_ACQ_DATE])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG], md[model.MD_LENS_MAG])
# None of the images are using light => no MD_IN_WL
self.assertFalse(model.MD_IN_WL in im.metadata,
"Reporting excitation wavelength while there is none")
if model.MD_WL_POLYNOMIAL in md:
pn = md[model.MD_WL_POLYNOMIAL]
# 2 formats possible
if model.MD_WL_LIST in im.metadata:
l = ldata[i].shape[0]
npn = polynomial.Polynomial(pn,
domain=[0, l - 1],
window=[0, l - 1])
wl = npn.linspace(l)[1]
self.assertEqual(im.metadata[model.MD_WL_LIST], wl)
else:
self.assertEqual(im.metadata[model.MD_WL_POLYNOMIAL], pn)
elif model.MD_WL_LIST in md:
wl = md[model.MD_WL_LIST]
self.assertEqual(im.metadata[model.MD_WL_LIST], wl)
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDTime(self):
"""
Checks that we can read back the metadata of an acquisition with time correlation
"""
shapes = [(512, 256), (1, 5220, 1, 50, 40), (1, 5000)]
metadata = [
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "test",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 2), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake time correlator",
model.MD_DESCRIPTION: "test3d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 16,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-6), # m/px
model.MD_PIXEL_DUR: 1e-9, # s
model.MD_TIME_OFFSET: -20e-9, # s, of the first time value
model.MD_OUT_WL: "pass-through",
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
},
{
model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake time correlator",
model.MD_DESCRIPTION: "test1d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 16,
model.MD_BINNING: (1, 128), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_PIXEL_DUR: 10e-9, # s
model.MD_TIME_OFFSET: -500e-9, # s, of the first time value
model.MD_OUT_WL: (500e-9, 600e-9),
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
model.MD_DIMS: "XT",
},
]
# create 1 simple greyscale image
ldata = []
a = model.DataArray(numpy.zeros(shapes[0], numpy.uint16), metadata[0])
ldata.append(a)
# Create 2D time correlated image
a = model.DataArray(numpy.zeros(shapes[1], numpy.uint32), metadata[1])
a[:, :, :, 1, 5] = 1
a[0, 10, 0, 1, 0] = 10000
ldata.append(a)
# Create time correlated spot acquisition
a = model.DataArray(numpy.zeros(shapes[2], numpy.uint32), metadata[2])
a[0, 10] = 20000
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (400, 300, 3)
thumbnail = model.DataArray(numpy.zeros(tshape, numpy.uint8))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for i, im in enumerate(rdata):
orshape = shapes[i]
if len(orshape) == 5:
self.assertEqual(orshape, im.shape)
md = metadata[i]
self.assertEqual(im.metadata[model.MD_DESCRIPTION], md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE], md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE], md[model.MD_ACQ_DATE])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG], md[model.MD_LENS_MAG])
# None of the images are using light => no MD_IN_WL
self.assertFalse(model.MD_IN_WL in im.metadata, "Reporting excitation wavelength while there is none")
if model.MD_PIXEL_DUR in md:
pxd = md[model.MD_PIXEL_DUR]
self.assertEqual(im.metadata[model.MD_PIXEL_DUR], pxd)
if model.MD_TIME_OFFSET in md:
tof = md[model.MD_TIME_OFFSET]
self.assertEqual(im.metadata[model.MD_TIME_OFFSET], tof)
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])
def testReadMDTime(self):
"""
Checks that we can read back the metadata of an acquisition with time correlation
"""
shapes = [(512, 256), (1, 5220, 1, 50, 40), (1, 5000)]
metadata = [{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake hw",
model.MD_DESCRIPTION: "test",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 12,
model.MD_BINNING: (1, 2), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
model.MD_LENS_MAG: 1200, # ratio
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake time correlator",
model.MD_DESCRIPTION: "test3d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 16,
model.MD_BINNING: (1, 1), # px, px
model.MD_PIXEL_SIZE: (1e-6, 2e-6), # m/px
model.MD_PIXEL_DUR: 1e-9, # s
model.MD_TIME_OFFSET:-20e-9, # s, of the first time value
model.MD_OUT_WL: "pass-through",
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
},
{model.MD_SW_VERSION: "1.0-test",
model.MD_HW_NAME: "fake time correlator",
model.MD_DESCRIPTION: "test1d",
model.MD_ACQ_DATE: time.time(),
model.MD_BPP: 16,
model.MD_BINNING: (1, 128), # px, px
model.MD_PIXEL_SIZE: (1e-6, 1e-6), # m/px
model.MD_PIXEL_DUR: 10e-9, # s
model.MD_TIME_OFFSET:-500e-9, # s, of the first time value
model.MD_OUT_WL: (500e-9, 600e-9),
model.MD_POS: (1e-3, -30e-3), # m
model.MD_DWELL_TIME: 1.2, # s
model.MD_DIMS: "XT",
},
]
# create 1 simple greyscale image
ldata = []
a = model.DataArray(numpy.zeros(shapes[0], numpy.uint16), metadata[0])
ldata.append(a)
# Create 2D time correlated image
a = model.DataArray(numpy.zeros(shapes[1], numpy.uint32), metadata[1])
a[:, :, :, 1, 5] = 1
a[0, 10, 0, 1, 0] = 10000
ldata.append(a)
# Create time correlated spot acquisition
a = model.DataArray(numpy.zeros(shapes[2], numpy.uint32), metadata[2])
a[0, 10] = 20000
ldata.append(a)
# thumbnail : small RGB completely red
tshape = (400, 300, 3)
thumbnail = model.DataArray(numpy.zeros(tshape, numpy.uint8))
thumbnail[:, :, 1] += 255 # green
# export
hdf5.export(FILENAME, ldata, thumbnail)
# check it's here
st = os.stat(FILENAME) # this test also that the file is created
self.assertGreater(st.st_size, 0)
# check data
rdata = hdf5.read_data(FILENAME)
self.assertEqual(len(rdata), len(ldata))
for i, im in enumerate(rdata):
orshape = shapes[i]
if len(orshape) == 5:
self.assertEqual(orshape, im.shape)
md = metadata[i]
self.assertEqual(im.metadata[model.MD_DESCRIPTION], md[model.MD_DESCRIPTION])
self.assertEqual(im.metadata[model.MD_POS], md[model.MD_POS])
self.assertEqual(im.metadata[model.MD_PIXEL_SIZE], md[model.MD_PIXEL_SIZE])
self.assertEqual(im.metadata[model.MD_ACQ_DATE], md[model.MD_ACQ_DATE])
if model.MD_LENS_MAG in md:
self.assertEqual(im.metadata[model.MD_LENS_MAG], md[model.MD_LENS_MAG])
# None of the images are using light => no MD_IN_WL
self.assertFalse(model.MD_IN_WL in im.metadata,
"Reporting excitation wavelength while there is none")
if model.MD_PIXEL_DUR in md:
pxd = md[model.MD_PIXEL_DUR]
self.assertEqual(im.metadata[model.MD_PIXEL_DUR], pxd)
if model.MD_TIME_OFFSET in md:
tof = md[model.MD_TIME_OFFSET]
self.assertEqual(im.metadata[model.MD_TIME_OFFSET], tof)
# check thumbnail
rthumbs = hdf5.read_thumbnail(FILENAME)
self.assertEqual(len(rthumbs), 1)
im = rthumbs[0]
self.assertEqual(im.shape, tshape)
self.assertEqual(im[0, 0].tolist(), [0, 255, 0])