summaryrefslogtreecommitdiff
path: root/silx/io/test/test_fabioh5.py
diff options
context:
space:
mode:
Diffstat (limited to 'silx/io/test/test_fabioh5.py')
-rwxr-xr-xsilx/io/test/test_fabioh5.py629
1 files changed, 0 insertions, 629 deletions
diff --git a/silx/io/test/test_fabioh5.py b/silx/io/test/test_fabioh5.py
deleted file mode 100755
index f2c85b1..0000000
--- a/silx/io/test/test_fabioh5.py
+++ /dev/null
@@ -1,629 +0,0 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2016-2018 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ############################################################################*/
-"""Tests for fabioh5 wrapper"""
-
-__authors__ = ["V. Valls"]
-__license__ = "MIT"
-__date__ = "02/07/2018"
-
-import os
-import logging
-import numpy
-import unittest
-import tempfile
-import shutil
-
-_logger = logging.getLogger(__name__)
-
-import fabio
-import h5py
-
-from .. import commonh5
-from .. import fabioh5
-
-
-class TestFabioH5(unittest.TestCase):
-
- def setUp(self):
-
- header = {
- "integer": "-100",
- "float": "1.0",
- "string": "hi!",
- "list_integer": "100 50 0",
- "list_float": "1.0 2.0 3.5",
- "string_looks_like_list": "2000 hi!",
- }
- data = numpy.array([[10, 11], [12, 13], [14, 15]], dtype=numpy.int64)
- self.fabio_image = fabio.numpyimage.NumpyImage(data, header)
- self.h5_image = fabioh5.File(fabio_image=self.fabio_image)
-
- def test_main_groups(self):
- self.assertEqual(self.h5_image.h5py_class, h5py.File)
- self.assertEqual(self.h5_image["/"].h5py_class, h5py.File)
- self.assertEqual(self.h5_image["/scan_0"].h5py_class, h5py.Group)
- self.assertEqual(self.h5_image["/scan_0/instrument"].h5py_class, h5py.Group)
- self.assertEqual(self.h5_image["/scan_0/measurement"].h5py_class, h5py.Group)
-
- def test_wrong_path_syntax(self):
- # result tested with a default h5py file
- self.assertRaises(ValueError, lambda: self.h5_image[""])
-
- def test_wrong_root_name(self):
- # result tested with a default h5py file
- self.assertRaises(KeyError, lambda: self.h5_image["/foo"])
-
- def test_wrong_root_path(self):
- # result tested with a default h5py file
- self.assertRaises(KeyError, lambda: self.h5_image["/foo/foo"])
-
- def test_wrong_name(self):
- # result tested with a default h5py file
- self.assertRaises(KeyError, lambda: self.h5_image["foo"])
-
- def test_wrong_path(self):
- # result tested with a default h5py file
- self.assertRaises(KeyError, lambda: self.h5_image["foo/foo"])
-
- def test_single_frame(self):
- data = numpy.arange(2 * 3)
- data.shape = 2, 3
- fabio_image = fabio.edfimage.edfimage(data=data)
- h5_image = fabioh5.File(fabio_image=fabio_image)
-
- dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertTrue(isinstance(dataset[()], numpy.ndarray))
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (2, 3))
- self.assertEqual(dataset[...][0, 0], 0)
- self.assertEqual(dataset.attrs["interpretation"], "image")
-
- def test_multi_frames(self):
- data = numpy.arange(2 * 3)
- data.shape = 2, 3
- fabio_image = fabio.edfimage.edfimage(data=data)
- fabio_image.append_frame(data=data)
- h5_image = fabioh5.File(fabio_image=fabio_image)
-
- dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertTrue(isinstance(dataset[()], numpy.ndarray))
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (2, 2, 3))
- self.assertEqual(dataset[...][0, 0, 0], 0)
- self.assertEqual(dataset.attrs["interpretation"], "image")
-
- def test_heterogeneous_frames(self):
- """Frames containing 2 images with different sizes and a cube"""
- data1 = numpy.arange(2 * 3)
- data1.shape = 2, 3
- data2 = numpy.arange(2 * 5)
- data2.shape = 2, 5
- data3 = numpy.arange(2 * 5 * 1)
- data3.shape = 2, 5, 1
- fabio_image = fabio.edfimage.edfimage(data=data1)
- fabio_image.append_frame(data=data2)
- fabio_image.append_frame(data=data3)
- h5_image = fabioh5.File(fabio_image=fabio_image)
-
- dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertTrue(isinstance(dataset[()], numpy.ndarray))
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (3, 2, 5, 1))
- self.assertEqual(dataset[...][0, 0, 0], 0)
- self.assertEqual(dataset.attrs["interpretation"], "image")
-
- def test_single_3d_frame(self):
- """Image source contains a cube"""
- data = numpy.arange(2 * 3 * 4)
- data.shape = 2, 3, 4
- # Do not provide the data to the constructor to avoid slicing of the
- # data. In this way the result stay a cube, and not a multi-frame
- fabio_image = fabio.edfimage.edfimage()
- fabio_image.data = data
- h5_image = fabioh5.File(fabio_image=fabio_image)
-
- dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertTrue(isinstance(dataset[()], numpy.ndarray))
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (2, 3, 4))
- self.assertEqual(dataset[...][0, 0, 0], 0)
- self.assertEqual(dataset.attrs["interpretation"], "image")
-
- def test_metadata_int(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/integer"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset[()], -100)
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (1,))
-
- def test_metadata_float(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/float"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset[()], 1.0)
- self.assertEqual(dataset.dtype.kind, "f")
- self.assertEqual(dataset.shape, (1,))
-
- def test_metadata_string(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/string"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset[()], numpy.string_("hi!"))
- self.assertEqual(dataset.dtype.type, numpy.string_)
- self.assertEqual(dataset.shape, (1,))
-
- def test_metadata_list_integer(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/list_integer"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset.dtype.kind, "u")
- self.assertEqual(dataset.shape, (1, 3))
- self.assertEqual(dataset[0, 0], 100)
- self.assertEqual(dataset[0, 1], 50)
-
- def test_metadata_list_float(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/list_float"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset.dtype.kind, "f")
- self.assertEqual(dataset.shape, (1, 3))
- self.assertEqual(dataset[0, 0], 1.0)
- self.assertEqual(dataset[0, 1], 2.0)
-
- def test_metadata_list_looks_like_list(self):
- dataset = self.h5_image["/scan_0/instrument/detector_0/others/string_looks_like_list"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertEqual(dataset[()], numpy.string_("2000 hi!"))
- self.assertEqual(dataset.dtype.type, numpy.string_)
- self.assertEqual(dataset.shape, (1,))
-
- def test_float_32(self):
- float_list = [u'1.2', u'1.3', u'1.4']
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = None
- for float_item in float_list:
- header = {"float_item": float_item}
- if fabio_image is None:
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_image.append_frame(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
- # There is no equality between items
- self.assertEqual(len(data), len(set(data)))
- # At worst a float32
- self.assertIn(data.dtype.kind, ['d', 'f'])
- self.assertLessEqual(data.dtype.itemsize, 32 / 8)
-
- def test_float_64(self):
- float_list = [
- u'1469117129.082226',
- u'1469117136.684986', u'1469117144.312749', u'1469117151.892507',
- u'1469117159.474265', u'1469117167.100027', u'1469117174.815799',
- u'1469117182.437561', u'1469117190.094326', u'1469117197.721089']
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = None
- for float_item in float_list:
- header = {"time_of_day": float_item}
- if fabio_image is None:
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_image.append_frame(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- data = h5_image["/scan_0/instrument/detector_0/others/time_of_day"]
- # There is no equality between items
- self.assertEqual(len(data), len(set(data)))
- # At least a float64
- self.assertIn(data.dtype.kind, ['d', 'f'])
- self.assertGreaterEqual(data.dtype.itemsize, 64 / 8)
-
- def test_mixed_float_size__scalar(self):
- # We expect to have a precision of 32 bits
- float_list = [u'1.2', u'1.3001']
- expected_float_result = [1.2, 1.3001]
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = None
- for float_item in float_list:
- header = {"float_item": float_item}
- if fabio_image is None:
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_image.append_frame(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
- # At worst a float32
- self.assertIn(data.dtype.kind, ['d', 'f'])
- self.assertLessEqual(data.dtype.itemsize, 32 / 8)
- for computed, expected in zip(data, expected_float_result):
- numpy.testing.assert_almost_equal(computed, expected, 5)
-
- def test_mixed_float_size__list(self):
- # We expect to have a precision of 32 bits
- float_list = [u'1.2 1.3001']
- expected_float_result = numpy.array([[1.2, 1.3001]])
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = None
- for float_item in float_list:
- header = {"float_item": float_item}
- if fabio_image is None:
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_image.append_frame(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
- # At worst a float32
- self.assertIn(data.dtype.kind, ['d', 'f'])
- self.assertLessEqual(data.dtype.itemsize, 32 / 8)
- for computed, expected in zip(data, expected_float_result):
- numpy.testing.assert_almost_equal(computed, expected, 5)
-
- def test_mixed_float_size__list_of_list(self):
- # We expect to have a precision of 32 bits
- float_list = [u'1.2 1.3001', u'1.3001 1.3001']
- expected_float_result = numpy.array([[1.2, 1.3001], [1.3001, 1.3001]])
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = None
- for float_item in float_list:
- header = {"float_item": float_item}
- if fabio_image is None:
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_image.append_frame(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- data = h5_image["/scan_0/instrument/detector_0/others/float_item"]
- # At worst a float32
- self.assertIn(data.dtype.kind, ['d', 'f'])
- self.assertLessEqual(data.dtype.itemsize, 32 / 8)
- for computed, expected in zip(data, expected_float_result):
- numpy.testing.assert_almost_equal(computed, expected, 5)
-
- def test_ub_matrix(self):
- """Data from mediapix.edf"""
- header = {}
- header["UB_mne"] = 'UB0 UB1 UB2 UB3 UB4 UB5 UB6 UB7 UB8'
- header["UB_pos"] = '1.99593e-16 2.73682e-16 -1.54 -1.08894 1.08894 1.6083e-16 1.08894 1.08894 9.28619e-17'
- header["sample_mne"] = 'U0 U1 U2 U3 U4 U5'
- header["sample_pos"] = '4.08 4.08 4.08 90 90 90'
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
- sample = h5_image["/scan_0/sample"]
- self.assertIsNotNone(sample)
- self.assertEqual(sample.attrs["NXclass"], "NXsample")
-
- d = sample['unit_cell_abc']
- expected = numpy.array([4.08, 4.08, 4.08])
- self.assertIsNotNone(d)
- self.assertEqual(d.shape, (3, ))
- self.assertIn(d.dtype.kind, ['d', 'f'])
- numpy.testing.assert_array_almost_equal(d[...], expected)
-
- d = sample['unit_cell_alphabetagamma']
- expected = numpy.array([90.0, 90.0, 90.0])
- self.assertIsNotNone(d)
- self.assertEqual(d.shape, (3, ))
- self.assertIn(d.dtype.kind, ['d', 'f'])
- numpy.testing.assert_array_almost_equal(d[...], expected)
-
- d = sample['ub_matrix']
- expected = numpy.array([[[1.99593e-16, 2.73682e-16, -1.54],
- [-1.08894, 1.08894, 1.6083e-16],
- [1.08894, 1.08894, 9.28619e-17]]])
- self.assertIsNotNone(d)
- self.assertEqual(d.shape, (1, 3, 3))
- self.assertIn(d.dtype.kind, ['d', 'f'])
- numpy.testing.assert_array_almost_equal(d[...], expected)
-
- def test_interpretation_mca_edf(self):
- """EDF files with two or more headers starting with "MCA"
- must have @interpretation = "spectrum" an the data."""
- header = {
- "Title": "zapimage samy -4.975 -5.095 80 500 samz -4.091 -4.171 70 0",
- "MCA a": -23.812,
- "MCA b": 2.7107,
- "MCA c": 8.1164e-06}
-
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = fabio.edfimage.EdfImage(data=data, header=header)
- h5_image = fabioh5.File(fabio_image=fabio_image)
-
- data_dataset = h5_image["/scan_0/measurement/image_0/data"]
- self.assertEqual(data_dataset.attrs["interpretation"], "spectrum")
-
- data_dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(data_dataset.attrs["interpretation"], "spectrum")
-
- data_dataset = h5_image["/scan_0/measurement/image_0/info/data"]
- self.assertEqual(data_dataset.attrs["interpretation"], "spectrum")
-
- def test_get_api(self):
- result = self.h5_image.get("scan_0", getclass=True, getlink=True)
- self.assertIs(result, h5py.HardLink)
- result = self.h5_image.get("scan_0", getclass=False, getlink=True)
- self.assertIsInstance(result, h5py.HardLink)
- result = self.h5_image.get("scan_0", getclass=True, getlink=False)
- self.assertIs(result, h5py.Group)
- result = self.h5_image.get("scan_0", getclass=False, getlink=False)
- self.assertIsInstance(result, commonh5.Group)
-
- def test_detector_link(self):
- detector1 = self.h5_image["/scan_0/instrument/detector_0"]
- detector2 = self.h5_image["/scan_0/measurement/image_0/info"]
- self.assertIsNot(detector1, detector2)
- self.assertEqual(list(detector1.items()), list(detector2.items()))
- self.assertEqual(self.h5_image.get(detector2.name, getlink=True).path, detector1.name)
-
- def test_detector_data_link(self):
- data1 = self.h5_image["/scan_0/instrument/detector_0/data"]
- data2 = self.h5_image["/scan_0/measurement/image_0/data"]
- self.assertIsNot(data1, data2)
- self.assertIs(data1._get_data(), data2._get_data())
- self.assertEqual(self.h5_image.get(data2.name, getlink=True).path, data1.name)
-
- def test_dirty_header(self):
- """Test that it does not fail"""
- try:
- header = {}
- header["foo"] = b'abc'
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = fabio.edfimage.edfimage(data=data, header=header)
- header = {}
- header["foo"] = b'a\x90bc\xFE'
- fabio_image.append_frame(data=data, header=header)
- except Exception as e:
- _logger.error(e.args[0])
- _logger.debug("Backtrace", exc_info=True)
- self.skipTest("fabio do not allow to create the resource")
-
- h5_image = fabioh5.File(fabio_image=fabio_image)
- scan_header_path = "/scan_0/instrument/file/scan_header"
- self.assertIn(scan_header_path, h5_image)
- data = h5_image[scan_header_path]
- self.assertIsInstance(data[...], numpy.ndarray)
-
- def test_unicode_header(self):
- """Test that it does not fail"""
- try:
- header = {}
- header["foo"] = b'abc'
- data = numpy.array([[0, 0], [0, 0]], dtype=numpy.int8)
- fabio_image = fabio.edfimage.edfimage(data=data, header=header)
- header = {}
- header["foo"] = u'abc\u2764'
- fabio_image.append_frame(data=data, header=header)
- except Exception as e:
- _logger.error(e.args[0])
- _logger.debug("Backtrace", exc_info=True)
- self.skipTest("fabio do not allow to create the resource")
-
- h5_image = fabioh5.File(fabio_image=fabio_image)
- scan_header_path = "/scan_0/instrument/file/scan_header"
- self.assertIn(scan_header_path, h5_image)
- data = h5_image[scan_header_path]
- self.assertIsInstance(data[...], numpy.ndarray)
-
-
-class TestFabioH5MultiFrames(unittest.TestCase):
-
- @classmethod
- def setUpClass(cls):
-
- names = ["A", "B", "C", "D"]
- values = [["32000", "-10", "5.0", "1"],
- ["-32000", "-10", "5.0", "1"]]
-
- fabio_file = None
-
- for i in range(10):
- header = {
- "image_id": "%d" % i,
- "integer": "-100",
- "float": "1.0",
- "string": "hi!",
- "list_integer": "100 50 0",
- "list_float": "1.0 2.0 3.5",
- "string_looks_like_list": "2000 hi!",
- "motor_mne": " ".join(names),
- "motor_pos": " ".join(values[i % len(values)]),
- "counter_mne": " ".join(names),
- "counter_pos": " ".join(values[i % len(values)])
- }
- for iname, name in enumerate(names):
- header[name] = values[i % len(values)][iname]
-
- data = numpy.array([[i, 11], [12, 13], [14, 15]], dtype=numpy.int64)
- if fabio_file is None:
- fabio_file = fabio.edfimage.EdfImage(data=data, header=header)
- else:
- fabio_file.append_frame(data=data, header=header)
-
- cls.fabio_file = fabio_file
- cls.fabioh5 = fabioh5.File(fabio_image=fabio_file)
-
- def test_others(self):
- others = self.fabioh5["/scan_0/instrument/detector_0/others"]
- dataset = others["A"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 1)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = others["B"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 1)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = others["C"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 1)
- self.assertEqual(dataset.dtype.kind, "f")
- dataset = others["D"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 1)
- self.assertEqual(dataset.dtype.kind, "u")
-
- def test_positioners(self):
- counters = self.fabioh5["/scan_0/instrument/positioners"]
- # At least 32 bits, no unsigned values
- dataset = counters["A"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = counters["B"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = counters["C"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "f")
- dataset = counters["D"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
-
- def test_counters(self):
- counters = self.fabioh5["/scan_0/measurement"]
- # At least 32 bits, no unsigned values
- dataset = counters["A"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = counters["B"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
- dataset = counters["C"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "f")
- dataset = counters["D"]
- self.assertGreaterEqual(dataset.dtype.itemsize, 4)
- self.assertEqual(dataset.dtype.kind, "i")
-
-
-class TestFabioH5WithEdf(unittest.TestCase):
-
- @classmethod
- def setUpClass(cls):
-
- cls.tmp_directory = tempfile.mkdtemp()
-
- cls.edf_filename = os.path.join(cls.tmp_directory, "test.edf")
-
- header = {
- "integer": "-100",
- "float": "1.0",
- "string": "hi!",
- "list_integer": "100 50 0",
- "list_float": "1.0 2.0 3.5",
- "string_looks_like_list": "2000 hi!",
- }
- data = numpy.array([[10, 11], [12, 13], [14, 15]], dtype=numpy.int64)
- fabio_image = fabio.edfimage.edfimage(data, header)
- fabio_image.write(cls.edf_filename)
-
- cls.fabio_image = fabio.open(cls.edf_filename)
- cls.h5_image = fabioh5.File(fabio_image=cls.fabio_image)
-
- @classmethod
- def tearDownClass(cls):
- cls.fabio_image = None
- cls.h5_image = None
- shutil.rmtree(cls.tmp_directory)
-
- def test_reserved_format_metadata(self):
- if fabio.hexversion < 327920: # 0.5.0 final
- self.skipTest("fabio >= 0.5.0 final is needed")
-
- # The EDF contains reserved keys in the header
- self.assertIn("HeaderID", self.fabio_image.header)
- # We do not expose them in FabioH5
- self.assertNotIn("/scan_0/instrument/detector_0/others/HeaderID", self.h5_image)
-
-
-class _TestableFrameData(fabioh5.FrameData):
- """Allow to test if the full data is reached."""
- def _create_data(self):
- raise RuntimeError("Not supposed to be called")
-
-
-class TestFabioH5WithFileSeries(unittest.TestCase):
-
- @classmethod
- def setUpClass(cls):
-
- cls.tmp_directory = tempfile.mkdtemp()
-
- cls.edf_filenames = []
-
- for i in range(10):
- filename = os.path.join(cls.tmp_directory, "test_%04d.edf" % i)
- cls.edf_filenames.append(filename)
-
- header = {
- "image_id": "%d" % i,
- "integer": "-100",
- "float": "1.0",
- "string": "hi!",
- "list_integer": "100 50 0",
- "list_float": "1.0 2.0 3.5",
- "string_looks_like_list": "2000 hi!",
- }
- data = numpy.array([[i, 11], [12, 13], [14, 15]], dtype=numpy.int64)
- fabio_image = fabio.edfimage.edfimage(data, header)
- fabio_image.write(filename)
-
- @classmethod
- def tearDownClass(cls):
- shutil.rmtree(cls.tmp_directory)
-
- def _testH5Image(self, h5_image):
- # test data
- dataset = h5_image["/scan_0/instrument/detector_0/data"]
- self.assertEqual(dataset.h5py_class, h5py.Dataset)
- self.assertTrue(isinstance(dataset[()], numpy.ndarray))
- self.assertEqual(dataset.dtype.kind, "i")
- self.assertEqual(dataset.shape, (10, 3, 2))
- self.assertEqual(list(dataset[:, 0, 0]), list(range(10)))
- self.assertEqual(dataset.attrs["interpretation"], "image")
- # test metatdata
- dataset = h5_image["/scan_0/instrument/detector_0/others/image_id"]
- self.assertEqual(list(dataset[...]), list(range(10)))
-
- def testFileList(self):
- h5_image = fabioh5.File(file_series=self.edf_filenames)
- self._testH5Image(h5_image)
-
- def testFileSeries(self):
- file_series = fabioh5._FileSeries(self.edf_filenames)
- h5_image = fabioh5.File(file_series=file_series)
- self._testH5Image(h5_image)
-
- def testFrameDataCache(self):
- file_series = fabioh5._FileSeries(self.edf_filenames)
- reader = fabioh5.FabioReader(file_series=file_series)
- frameData = _TestableFrameData("foo", reader)
- self.assertEqual(frameData.dtype.kind, "i")
- self.assertEqual(frameData.shape, (10, 3, 2))
-
-
-def suite():
- loadTests = unittest.defaultTestLoader.loadTestsFromTestCase
- test_suite = unittest.TestSuite()
- test_suite.addTest(loadTests(TestFabioH5))
- test_suite.addTest(loadTests(TestFabioH5MultiFrames))
- test_suite.addTest(loadTests(TestFabioH5WithEdf))
- test_suite.addTest(loadTests(TestFabioH5WithFileSeries))
- return test_suite
-
-
-if __name__ == '__main__':
- unittest.main(defaultTest="suite")