def test_different_read_modes():
dname1, dname2, fname1, fname2 = _prepare()
for fname, dname, n in [(fname1, dname1, 1), (fname2, dname2, 2)]:
# Test imread()
im = imageio.imread(fname)
assert isinstance(im, np.ndarray)
assert im.shape == (512, 512)
# Test mimread()
ims = imageio.mimread(fname)
assert isinstance(ims, list)
assert ims[0].shape == im.shape
assert len(ims) > 1
#
ims2 = imageio.mimread(dname)
assert len(ims) == len(ims2)
# Test volread()
vol = imageio.volread(dname)
assert vol.ndim == 3
assert vol.shape[0] > 10
assert vol.shape[1:] == (512, 512)
#
vol2 = imageio.volread(fname) # fname works as well
assert (vol == vol2).all()
# Test mvolread()
vols = imageio.mvolread(dname)
assert isinstance(vols, list)
assert len(vols) == n
assert vols[0].shape == vol.shape
assert sum([v.shape[0] for v in vols]) == len(ims)
def test_different_read_modes():
dname1, dname2, fname1, fname2 = _prepare()
for fname, dname, n in [(fname1, dname1, 1), (fname2, dname2, 2)]:
# Test imread()
im = imageio.imread(fname)
assert isinstance(im, np.ndarray)
assert im.shape == (512, 512)
# Test mimread()
ims = imageio.mimread(fname)
assert isinstance(ims, list)
assert ims[0].shape == im.shape
assert len(ims) > 1
#
ims2 = imageio.mimread(dname)
assert len(ims) == len(ims2)
# Test volread()
vol = imageio.volread(dname)
assert vol.ndim == 3
assert vol.shape[0] > 10
assert vol.shape[1:] == (512, 512)
#
vol2 = imageio.volread(fname) # fname works as well
assert (vol == vol2).all()
# Test mvolread()
vols = imageio.mvolread(dname)
assert isinstance(vols, list)
assert len(vols) == n
assert vols[0].shape == vol.shape
assert sum([v.shape[0] for v in vols]) == len(ims)
def test_npz_reading_writing(tmp_path):
"""Test reading and saveing npz"""
if IS_PYPY:
return # no support for npz format :(
im2 = np.ones((10, 10), np.uint8) * 2
im3 = np.ones((10, 10, 10), np.uint8) * 3
im4 = np.ones((10, 10, 10, 10), np.uint8) * 4
filename1 = tmp_path / "test_npz.npz"
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 3
# Volumes
imageio.mvolsave(filename1, [im3, im3])
im = imageio.volread(filename1)
ims = imageio.mvolread(filename1)
assert (im == im3).all()
assert len(ims) == 2
# Mixed
W = imageio.save(filename1)
assert W.format.name == "NPZ"
W.append_data(im2)
W.append_data(im3)
W.append_data(im4)
pytest.raises(RuntimeError, W.set_meta_data, {}) # no meta data support
W.close()
#
R = imageio.read(filename1)
assert R.format.name == "NPZ"
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
assert (ims[1] == im3).all()
assert (ims[2] == im4).all()
# Fail
pytest.raises(IndexError, R.get_data, -1)
pytest.raises(IndexError, R.get_data, 3)
pytest.raises(RuntimeError, R.get_meta_data, None) # no meta data support
pytest.raises(RuntimeError, R.get_meta_data, 0) # no meta data support
def test_npz_reading_writing():
""" Test reading and saveing npz """
if IS_PYPY:
return # no support for npz format :(
im2 = np.ones((10, 10), np.uint8) * 2
im3 = np.ones((10, 10, 10), np.uint8) * 3
im4 = np.ones((10, 10, 10, 10), np.uint8) * 4
filename1 = os.path.join(test_dir, 'test_npz.npz')
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 3
# Volumes
imageio.mvolsave(filename1, [im3, im3])
im = imageio.volread(filename1)
ims = imageio.mvolread(filename1)
assert (im == im3).all()
assert len(ims) == 2
# Mixed
W = imageio.save(filename1)
assert W.format.name == 'NPZ'
W.append_data(im2)
W.append_data(im3)
W.append_data(im4)
raises(RuntimeError, W.set_meta_data, {}) # no meta data support
W.close()
#
R = imageio.read(filename1)
assert R.format.name == 'NPZ'
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
assert (ims[1] == im3).all()
assert (ims[2] == im4).all()
# Fail
raises(IndexError, R.get_data, -1)
raises(IndexError, R.get_data, 3)
raises(RuntimeError, R.get_meta_data, None) # no meta data support
raises(RuntimeError, R.get_meta_data, 0) # no meta data support
def test_spe_reading():
need_internet()
fname = get_remote_file("images/test_000_.SPE")
fr1 = np.zeros((32, 32), np.uint16)
fr2 = np.ones_like(fr1)
# Test imread
im = imageio.imread(fname)
ims = imageio.mimread(fname)
np.testing.assert_equal(im, fr1)
np.testing.assert_equal(ims, [fr1, fr2])
# Test volread
vol = imageio.volread(fname)
vols = imageio.mvolread(fname)
np.testing.assert_equal(vol, [fr1, fr2])
np.testing.assert_equal(vols, [[fr1, fr2]])
# Test get_reader
r = imageio.get_reader(fname)
np.testing.assert_equal(r.get_data(1), fr2)
np.testing.assert_equal(list(r), [fr1, fr2])
pytest.raises(IndexError, r.get_data, -1)
pytest.raises(IndexError, r.get_data, 2)
# check metadata
md = r.get_meta_data()
assert (md["ROIs"] == [{
"top_left": [238, 187],
"bottom_right": [269, 218],
"bin": [1, 1]
}])
cmt = [
"OD 1.0 in r, g "
" ",
"000200000000000004800000000000000000000000000000000000000000000000"
"0002000001000X",
" "
" ",
" "
" ",
"ACCI2xSEQU-1---10000010001600300EA SW"
"0218COMVER0500"
]
assert (md["comments"] == cmt)
np.testing.assert_equal(md["frame_shape"], fr1.shape)
def _LoadMov(file, fold=FOLD_TMP, *, fmt=FMT.TIF):
"""
Reads multiple 2D arrays `mov` [F,Z,Y,X] from a multilayer .tif (organized as [F,Y,X,Z]!)
"""
## Read from File ##
# Turn off `memtest` because we're liable to read some very large files #
mov = np.array(imageio.mvolread(fold + file + str(fmt), memtest=False)[0])
if (len(np.shape(mov)) == 2):
mov = mov[None, None, :, :]
elif (len(np.shape(mov)) == 3):
mov = mov[:, None, :, :]
else: # This allows z-stack imaging! #
mov = np.moveaxis(mov, 3, 1)
return mov
def test_spe_reading():
need_internet()
fname = get_remote_file("images/test_000_.SPE")
fr1 = np.zeros((32, 32), np.uint16)
fr2 = np.ones_like(fr1)
# Test imread
im = imageio.imread(fname)
ims = imageio.mimread(fname)
np.testing.assert_equal(im, fr1)
np.testing.assert_equal(ims, [fr1, fr2])
# Test volread
vol = imageio.volread(fname)
vols = imageio.mvolread(fname)
np.testing.assert_equal(vol, [fr1, fr2])
np.testing.assert_equal(vols, [[fr1, fr2]])
# Test get_reader
r = imageio.get_reader(fname)
np.testing.assert_equal(r.get_data(1), fr2)
np.testing.assert_equal(list(r), [fr1, fr2])
pytest.raises(IndexError, r.get_data, -1)
pytest.raises(IndexError, r.get_data, 2)
# check metadata
md = r.get_meta_data()
assert md["ROIs"] == [
{"top_left": [238, 187], "bottom_right": [269, 218], "bin": [1, 1]}
]
cmt = [
"OD 1.0 in r, g "
" ",
"000200000000000004800000000000000000000000000000000000000000000000"
"0002000001000X",
" "
" ",
" "
" ",
"ACCI2xSEQU-1---10000010001600300EA SW"
"0218COMVER0500",
]
assert md["comments"] == cmt
np.testing.assert_equal(md["frame_shape"], fr1.shape)
def test_dicom():
# Test volread()
fname1 = get_remote_file('images/dicom_sample.zip', test_dir)
dname1 = fname1[:-4]
z = ZipFile(fname1)
z.extractall(dname1)
#
vol = imageio.volread(dname1, 'DICOM')
assert vol.ndim == 3
assert vol.shape[0] > 20
assert vol.shape[1] == 512
assert vol.shape[2] == 512
# Test volsave()
raises(ValueError, imageio.volsave, dname1, vol)
raises(ValueError, imageio.volsave, dname1, np.zeros((100, 100, 100, 3)))
# todo: we have no format to save volumes yet!
# Test mvolread()
vols = imageio.mvolread(dname1, 'DICOM')
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
def test_spe_reading(test_images):
fname = test_images / "test_000_.SPE"
fr1 = np.zeros((32, 32), np.uint16)
fr2 = np.ones_like(fr1)
# Test imread
im = imageio.imread(fname)
ims = imageio.mimread(fname)
np.testing.assert_equal(im, fr1)
np.testing.assert_equal(ims, [fr1, fr2])
# Test volread
vol = imageio.volread(fname)
vols = imageio.mvolread(fname)
np.testing.assert_equal(vol, [fr1, fr2])
np.testing.assert_equal(vols, [[fr1, fr2]])
# Test get_reader
r = imageio.get_reader(fname, sdt_meta=False)
np.testing.assert_equal(r.get_data(1), fr2)
np.testing.assert_equal(list(r), [fr1, fr2])
pytest.raises(IndexError, r.get_data, -1)
pytest.raises(IndexError, r.get_data, 2)
# check metadata
md = r.get_meta_data()
assert md["ROIs"] == [
{"top_left": [238, 187], "bottom_right": [269, 218], "bin": [1, 1]}
]
cmt = [
"OD 1.0 in r, g "
" ",
"000200000000000004800000000000000000000000000000000000000000000000"
"0002000001000X",
" "
" ",
" "
" ",
"ACCI2xSEQU-1---10000010001600300EA SW"
"0218COMVER0500",
]
assert md["comments"] == cmt
np.testing.assert_equal(md["frame_shape"], fr1.shape)
# Check reading SDT-control metadata
with imageio.get_reader(fname) as r2:
sdt_meta = r2.get_meta_data()
assert sdt_meta["delay_shutter"] == pytest.approx(0.001)
assert sdt_meta["delay_macro"] == pytest.approx(0.048)
assert sdt_meta["exposure_time"] == pytest.approx(0.002)
assert sdt_meta["comment"] == "OD 1.0 in r, g"
assert sdt_meta["datetime"] == datetime(2018, 7, 2, 9, 46, 15)
assert sdt_meta["sdt_major_version"] == 2
assert sdt_meta["sdt_minor_version"] == 18
assert isinstance(sdt_meta["modulation_script"], str)
assert sdt_meta["sequence_type"] == "standard"
def test_tifffile_reading_writing():
""" Test reading and saving tiff """
need_internet() # We keep a test image in the imageio-binary repo
im2 = np.ones((10, 10, 3), np.uint8) * 2
filename1 = os.path.join(test_dir, "test_tiff.tiff")
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all() # note: this does not imply that the shape match!
assert len(ims) == 3
for i in range(3):
assert ims[i].shape == im2.shape
assert (ims[i] == im2).all()
# Read all planes as one array - we call it a volume for clarity
vol = imageio.volread(filename1)
vols = imageio.mvolread(filename1)
assert vol.shape == (3, ) + im2.shape
assert len(vols) == 1 and vol.shape == vols[0].shape
for i in range(3):
assert (vol[i] == im2).all()
# remote multipage rgb file
filename2 = get_remote_file("images/multipage_rgb.tif")
img = imageio.mimread(filename2)
assert len(img) == 2
assert img[0].shape == (3, 10, 10)
# Mixed
W = imageio.save(filename1)
W.set_meta_data({"planarconfig": "SEPARATE"}) # was "planar"
assert W.format.name == "TIFF"
W.append_data(im2)
W.append_data(im2)
W.close()
#
R = imageio.read(filename1)
assert R.format.name == "TIFF"
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
# meta = R.get_meta_data()
# assert meta['orientation'] == 'top_left' # not there in later version
# Fail
raises(IndexError, R.get_data, -1)
raises(IndexError, R.get_data, 3)
# Ensure imread + imwrite works round trip
filename3 = os.path.join(test_dir, "test_tiff2.tiff")
im1 = imageio.imread(filename1)
imageio.imwrite(filename3, im1)
im3 = imageio.imread(filename3)
assert im1.ndim == 3
assert im1.shape == im3.shape
assert (im1 == im3).all()
# Ensure imread + imwrite works round trip - volume like
filename3 = os.path.join(test_dir, "test_tiff2.tiff")
im1 = imageio.volread(filename1)
imageio.volwrite(filename3, im1)
im3 = imageio.volread(filename3)
assert im1.ndim == 4
assert im1.shape == im3.shape
assert (im1 == im3).all()
# Read metadata
md = imageio.get_reader(filename2).get_meta_data()
assert md["is_imagej"] is None
assert md["description"] == "shape=(2,3,10,10)"
assert md["description1"] == ""
assert md["datetime"] == datetime.datetime(2015, 5, 9, 9, 8, 29)
assert md["software"] == "tifffile.py"
# Write metadata
dt = datetime.datetime(2018, 8, 6, 15, 35, 5)
with imageio.get_writer(filename1, software="testsoftware") as w:
w.append_data(np.zeros((10, 10)),
meta={
"description": "test desc",
"datetime": dt
})
w.append_data(np.zeros((10, 10)), meta={"description": "another desc"})
with imageio.get_reader(filename1) as r:
for md in r.get_meta_data(), r.get_meta_data(0):
assert "datetime" in md
assert md["datetime"] == dt
assert "software" in md
assert md["software"] == "testsoftware"
assert "description" in md
assert md["description"] == "test desc"
md = r.get_meta_data(1)
assert "description" in md
assert md["description"] == "another desc"
def test_mvolread_out_of_bytes():
with pytest.raises(RuntimeError):
imageio.mvolread(
"https://github.com/imageio/imageio-binaries/blob/master/images/multipage_rgb.tif?raw=true",
memtest="1B",
)
def test_functions():
""" Test the user-facing API functions """
# Test help(), it prints stuff, so we just check whether that goes ok
imageio.help() # should print overview
imageio.help("PNG") # should print about PNG
fname1 = get_remote_file("images/chelsea.png", test_dir)
fname2 = fname1[:-3] + "jpg"
fname3 = fname1[:-3] + "notavalidext"
open(fname3, "wb")
# Test read()
R1 = imageio.read(fname1)
R2 = imageio.read(fname1, "png")
assert R1.format is R2.format
# Fail
raises(ValueError, imageio.read, fname3) # existing but not readable
raises(FileNotFoundError, imageio.read, "notexisting.barf")
raises(IndexError, imageio.read, fname1, "notexistingformat")
# Test save()
W1 = imageio.save(fname2)
W2 = imageio.save(fname2, "JPG")
W1.close()
W2.close()
assert W1.format is W2.format
# Fail
raises(FileNotFoundError, imageio.save, "~/dirdoesnotexist/wtf.notexistingfile")
# Test imread()
im1 = imageio.imread(fname1)
im2 = imageio.imread(fname1, "png")
assert im1.shape[2] == 3
assert np.all(im1 == im2)
# Test imsave()
if os.path.isfile(fname2):
os.remove(fname2)
assert not os.path.isfile(fname2)
imageio.imsave(fname2, im1[:, :, 0])
imageio.imsave(fname2, im1)
assert os.path.isfile(fname2)
# Test mimread()
fname3 = get_remote_file("images/newtonscradle.gif", test_dir)
ims = imageio.mimread(fname3)
assert isinstance(ims, list)
assert len(ims) > 1
assert ims[0].ndim == 3
assert ims[0].shape[2] in (1, 3, 4)
# Test protection
with raises(RuntimeError):
imageio.mimread("imageio:chelsea.png", "dummy", length=np.inf)
if IS_PYPY:
return # no support for npz format :(
# Test mimsave()
fname5 = fname3[:-4] + "2.npz"
if os.path.isfile(fname5):
os.remove(fname5)
assert not os.path.isfile(fname5)
imageio.mimsave(fname5, [im[:, :, 0] for im in ims])
imageio.mimsave(fname5, ims)
assert os.path.isfile(fname5)
# Test volread()
fname4 = get_remote_file("images/stent.npz", test_dir)
vol = imageio.volread(fname4)
assert vol.ndim == 3
assert vol.shape[0] == 256
assert vol.shape[1] == 128
assert vol.shape[2] == 128
# Test volsave()
volc = np.zeros((10, 10, 10, 3), np.uint8) # color volume
fname6 = os.path.join(test_dir, "images", "stent2.npz")
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.volsave(fname6, volc)
imageio.volsave(fname6, vol)
assert os.path.isfile(fname6)
# Test mvolread()
vols = imageio.mvolread(fname4)
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
# Test mvolsave()
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.mvolsave(fname6, [volc, volc])
imageio.mvolsave(fname6, vols)
assert os.path.isfile(fname6)
# Fail for save functions
raises(ValueError, imageio.imsave, fname2, np.zeros((100, 100, 5)))
raises(ValueError, imageio.imsave, fname2, 42)
raises(ValueError, imageio.mimsave, fname5, [np.zeros((100, 100, 5))])
raises(ValueError, imageio.mimsave, fname5, [42])
raises(ValueError, imageio.volsave, fname6, np.zeros((100, 100, 100, 40)))
raises(ValueError, imageio.volsave, fname6, 42)
raises(ValueError, imageio.mvolsave, fname6, [np.zeros((90, 90, 90, 40))])
raises(ValueError, imageio.mvolsave, fname6, [42])
def test_functions(test_images, tmp_path):
"""Test the user-facing API functions"""
# Test help(), it prints stuff, so we just check whether that goes ok
imageio.help() # should print overview
imageio.help("PNG") # should print about PNG
fname1 = test_images / "chelsea.png"
fname2 = tmp_path / fname1.with_suffix(".jpg").name
fname3 = tmp_path / fname1.with_suffix(".notavalidext").name
open(fname3, "wb")
# Test read()
R1 = imageio.read(fname1)
R2 = imageio.read(fname1, "png")
# this tests if the highest priority png plugin and the highest
# priority fallback plugin match.
# Do we really what to enforce this?
assert type(R1) is type(R2)
raises(ValueError, imageio.read, fname3) # existing but not readable
raises(IndexError, imageio.read, fname1, "notexistingformat")
# Note: This is actually a test of Requests. We should probably
# migrate or remove it.
raises(FileNotFoundError, imageio.read, "notexisting.barf")
# Test save()
W1 = imageio.save(fname2)
W2 = imageio.save(fname2, "JPG")
W1.close()
W2.close()
assert type(W1) is type(W2)
# Fail
raises(FileNotFoundError, imageio.save,
"~/dirdoesnotexist/wtf.notexistingfile")
# Test imread()
im1 = imageio.imread(fname1)
im2 = imageio.imread(fname1, "png")
assert im1.shape[2] == 3
assert np.all(im1 == im2)
# Test imsave()
if os.path.isfile(fname2):
os.remove(fname2)
assert not os.path.isfile(fname2)
imageio.imsave(fname2, im1[:, :, 0])
imageio.imsave(fname2, im1)
assert os.path.isfile(fname2)
# Test mimread()
fname3 = test_images / "newtonscradle.gif"
ims = imageio.mimread(fname3)
assert isinstance(ims, list)
assert len(ims) > 1
assert ims[0].ndim == 3
assert ims[0].shape[2] in (1, 3, 4)
# Test protection
with raises(RuntimeError):
imageio.mimread(test_images / "chelsea.png", "dummy", length=np.inf)
if IS_PYPY:
return # no support for npz format :(
# Test mimsave()
fname5 = str(fname3.with_suffix(""))
fname5 += "2.npz"
if os.path.isfile(fname5):
os.remove(fname5)
assert not os.path.isfile(fname5)
imageio.mimsave(fname5, [im[:, :, 0] for im in ims])
imageio.mimsave(fname5, ims)
assert os.path.isfile(fname5)
# Test volread()
fname4 = test_images / "stent.npz"
vol = imageio.volread(fname4)
assert vol.ndim == 3
assert vol.shape[0] == 256
assert vol.shape[1] == 128
assert vol.shape[2] == 128
# Test volsave()
volc = np.zeros((10, 10, 10, 3), np.uint8) # color volume
fname6 = tmp_path / "stent2.npz"
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.volsave(fname6, volc)
imageio.volsave(fname6, vol)
assert os.path.isfile(fname6)
# Test mvolread()
vols = imageio.mvolread(fname4)
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
# Test mvolsave()
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.mvolsave(fname6, [volc, volc])
imageio.mvolsave(fname6, vols)
assert os.path.isfile(fname6)
# Fail for save functions
raises(ValueError, imageio.imsave, fname2, np.zeros((100, 100, 5)))
raises(ValueError, imageio.imsave, fname2, 42)
raises(ValueError, imageio.mimsave, fname5, [np.zeros((100, 100, 5))])
raises(ValueError, imageio.mimsave, fname5, [42])
raises(ValueError, imageio.volsave, fname6, np.zeros((100, 100, 100, 40)))
raises(ValueError, imageio.volsave, fname6, 42)
raises(ValueError, imageio.mvolsave, fname6, [np.zeros((90, 90, 90, 40))])
raises(ValueError, imageio.mvolsave, fname6, [42])
def test_tifffile_reading_writing():
""" Test reading and saving tiff """
need_internet() # We keep a test image in the imageio-binary repo
im2 = np.ones((10, 10, 3), np.uint8) * 2
filename1 = os.path.join(test_dir, 'test_tiff.tiff')
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all() # note: this does not imply that the shape match!
assert len(ims) == 3
for i in range(3):
assert ims[i].shape == im2.shape
assert (ims[i] == im2).all()
# Read all planes as one array - we call it a volume for clarity
vol = imageio.volread(filename1)
vols = imageio.mvolread(filename1)
assert vol.shape == (3, ) + im2.shape
assert len(vols) == 1 and vol.shape == vols[0].shape
for i in range(3):
assert (vol[i] == im2).all()
# remote multipage rgb file
filename2 = get_remote_file('images/multipage_rgb.tif')
img = imageio.mimread(filename2)
assert len(img) == 2
assert img[0].shape == (3, 10, 10)
# Mixed
W = imageio.save(filename1)
W.set_meta_data({'planarconfig': 'SEPARATE'}) # was "planar"
assert W.format.name == 'TIFF'
W.append_data(im2)
W.append_data(im2)
W.close()
#
R = imageio.read(filename1)
assert R.format.name == 'TIFF'
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
# meta = R.get_meta_data()
# assert meta['orientation'] == 'top_left' # not there in later version
# Fail
raises(IndexError, R.get_data, -1)
raises(IndexError, R.get_data, 3)
# Ensure imread + imwrite works round trip
filename3 = os.path.join(test_dir, 'test_tiff2.tiff')
im1 = imageio.imread(filename1)
imageio.imwrite(filename3, im1)
im3 = imageio.imread(filename3)
assert im1.ndim == 3
assert im1.shape == im3.shape
assert (im1 == im3).all()
# Ensure imread + imwrite works round trip - volume like
filename3 = os.path.join(test_dir, 'test_tiff2.tiff')
im1 = imageio.volread(filename1)
imageio.volwrite(filename3, im1)
im3 = imageio.volread(filename3)
assert im1.ndim == 4
assert im1.shape == im3.shape
assert (im1 == im3).all()
def test_tifffile_reading_writing():
""" Test reading and saving tiff """
need_internet() # We keep a test image in the imageio-binary repo
im2 = np.ones((10, 10, 3), np.uint8) * 2
filename1 = os.path.join(test_dir, 'test_tiff.tiff')
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert im.shape == im2.shape
assert (im == im2).all() # note: this does not imply that the shape match!
assert len(ims) == 3
for i in range(3):
assert ims[i].shape == im2.shape
assert (ims[i] == im2).all()
# Read all planes as one array - we call it a volume for clarity
vol = imageio.volread(filename1)
vols = imageio.mvolread(filename1)
assert vol.shape == (3, ) + im2.shape
assert len(vols) == 1 and vol.shape == vols[0].shape
for i in range(3):
assert (vol[i] == im2).all()
# remote multipage rgb file
filename2 = get_remote_file('images/multipage_rgb.tif')
img = imageio.mimread(filename2)
assert len(img) == 2
assert img[0].shape == (3, 10, 10)
# Mixed
W = imageio.save(filename1)
W.set_meta_data({'planarconfig': 'SEPARATE'}) # was "planar"
assert W.format.name == 'TIFF'
W.append_data(im2)
W.append_data(im2)
W.close()
#
R = imageio.read(filename1)
assert R.format.name == 'TIFF'
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
# meta = R.get_meta_data()
# assert meta['orientation'] == 'top_left' # not there in later version
# Fail
raises(IndexError, R.get_data, -1)
raises(IndexError, R.get_data, 3)
# Ensure imread + imwrite works round trip
filename3 = os.path.join(test_dir, 'test_tiff2.tiff')
im1 = imageio.imread(filename1)
imageio.imwrite(filename3, im1)
im3 = imageio.imread(filename3)
assert im1.ndim == 3
assert im1.shape == im3.shape
assert (im1 == im3).all()
# Ensure imread + imwrite works round trip - volume like
filename3 = os.path.join(test_dir, 'test_tiff2.tiff')
im1 = imageio.volread(filename1)
imageio.volwrite(filename3, im1)
im3 = imageio.volread(filename3)
assert im1.ndim == 4
assert im1.shape == im3.shape
assert (im1 == im3).all()
# Read metadata
md = imageio.get_reader(filename2).get_meta_data()
assert md['is_imagej'] is None
assert md['description'] == 'shape=(2,3,10,10)'
assert md['description1'] == ''
assert md['datetime'] == datetime.datetime(2015, 5, 9, 9, 8, 29)
assert md['software'] == 'tifffile.py'
# Write metadata
dt = datetime.datetime(2018, 8, 6, 15, 35, 5)
w = imageio.get_writer(filename1, software='testsoftware')
w.append_data(np.zeros((10, 10)), meta={'description': 'test desc',
'datetime': dt})
w.close()
r = imageio.get_reader(filename1)
md = r.get_meta_data()
assert 'datetime' in md
assert md['datetime'] == dt
assert 'software' in md
assert md['software'] == 'testsoftware'
assert 'description' in md
assert md['description'] == 'test desc'
def test_functions():
""" Test the user-facing API functions """
# Test help(), it prints stuff, so we just check whether that goes ok
imageio.help() # should print overview
imageio.help('PNG') # should print about PNG
fname1 = get_remote_file('images/chelsea.png', test_dir)
fname2 = fname1[:-3] + 'jpg'
fname3 = fname1[:-3] + 'notavalidext'
open(fname3, 'wb')
# Test read()
R1 = imageio.read(fname1)
R2 = imageio.read(fname1, 'png')
assert R1.format is R2.format
# Fail
raises(ValueError, imageio.read, fname3) # existing but not readable
raises(IOError, imageio.read, 'notexisting.barf')
raises(IndexError, imageio.read, fname1, 'notexistingformat')
# Test save()
W1 = imageio.save(fname2)
W2 = imageio.save(fname2, 'JPG')
assert W1.format is W2.format
# Fail
raises(ValueError, imageio.save, 'wtf.notexistingfile')
# Test imread()
im1 = imageio.imread(fname1)
im2 = imageio.imread(fname1, 'png')
assert im1.shape[2] == 3
assert np.all(im1 == im2)
# Test imsave()
if os.path.isfile(fname2):
os.remove(fname2)
assert not os.path.isfile(fname2)
imageio.imsave(fname2, im1[:, :, 0])
imageio.imsave(fname2, im1)
assert os.path.isfile(fname2)
# Test mimread()
fname3 = get_remote_file('images/newtonscradle.gif', test_dir)
ims = imageio.mimread(fname3)
assert isinstance(ims, list)
assert len(ims) > 1
assert ims[0].ndim == 3
assert ims[0].shape[2] in (1, 3, 4)
if IS_PYPY:
return # no support for npz format :(
# Test mimsave()
fname5 = fname3[:-4] + '2.npz'
if os.path.isfile(fname5):
os.remove(fname5)
assert not os.path.isfile(fname5)
imageio.mimsave(fname5, [im[:, :, 0] for im in ims])
imageio.mimsave(fname5, ims)
assert os.path.isfile(fname5)
# Test volread()
fname4 = get_remote_file('images/stent.npz', test_dir)
vol = imageio.volread(fname4)
assert vol.ndim == 3
assert vol.shape[0] == 256
assert vol.shape[1] == 128
assert vol.shape[2] == 128
# Test volsave()
volc = np.zeros((10, 10, 10, 3), np.uint8) # color volume
fname6 = fname4[:-4] + '2.npz'
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.volsave(fname6, volc)
imageio.volsave(fname6, vol)
assert os.path.isfile(fname6)
# Test mvolread()
vols = imageio.mvolread(fname4)
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
# Test mvolsave()
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.mvolsave(fname6, [volc, volc])
imageio.mvolsave(fname6, vols)
assert os.path.isfile(fname6)
# Fail for save functions
raises(ValueError, imageio.imsave, fname2, np.zeros((100, 100, 5)))
raises(ValueError, imageio.imsave, fname2, 42)
raises(ValueError, imageio.mimsave, fname5, [np.zeros((100, 100, 5))])
raises(ValueError, imageio.mimsave, fname5, [42])
raises(ValueError, imageio.volsave, fname4, np.zeros((100, 100, 100, 40)))
raises(ValueError, imageio.volsave, fname4, 42)
raises(ValueError, imageio.mvolsave, fname4, [np.zeros((90, 90, 90, 40))])
raises(ValueError, imageio.mvolsave, fname4, [42])
def test_functions():
""" Test the user-facing API functions """
# Test help(), it prints stuff, so we just check whether that goes ok
imageio.help() # should print overview
imageio.help("PNG") # should print about PNG
fname1 = get_remote_file("images/chelsea.png", test_dir)
fname2 = fname1[:-3] + "jpg"
fname3 = fname1[:-3] + "notavalidext"
open(fname3, "wb")
# Test read()
R1 = imageio.read(fname1)
R2 = imageio.read(fname1, "png")
assert R1.format is R2.format
# Fail
raises(ValueError, imageio.read, fname3) # existing but not readable
raises(FileNotFoundError, imageio.read, "notexisting.barf")
raises(IndexError, imageio.read, fname1, "notexistingformat")
# Test save()
W1 = imageio.save(fname2)
W2 = imageio.save(fname2, "JPG")
W1.close()
W2.close()
assert W1.format is W2.format
# Fail
raises(FileNotFoundError, imageio.save,
"~/dirdoesnotexist/wtf.notexistingfile")
# Test imread()
im1 = imageio.imread(fname1)
im2 = imageio.imread(fname1, "png")
assert im1.shape[2] == 3
assert np.all(im1 == im2)
# Test imsave()
if os.path.isfile(fname2):
os.remove(fname2)
assert not os.path.isfile(fname2)
imageio.imsave(fname2, im1[:, :, 0])
imageio.imsave(fname2, im1)
assert os.path.isfile(fname2)
# Test mimread()
fname3 = get_remote_file("images/newtonscradle.gif", test_dir)
ims = imageio.mimread(fname3)
assert isinstance(ims, list)
assert len(ims) > 1
assert ims[0].ndim == 3
assert ims[0].shape[2] in (1, 3, 4)
# Test protection
with raises(RuntimeError):
imageio.mimread("imageio:chelsea.png", "dummy", length=np.inf)
if IS_PYPY:
return # no support for npz format :(
# Test mimsave()
fname5 = fname3[:-4] + "2.npz"
if os.path.isfile(fname5):
os.remove(fname5)
assert not os.path.isfile(fname5)
imageio.mimsave(fname5, [im[:, :, 0] for im in ims])
imageio.mimsave(fname5, ims)
assert os.path.isfile(fname5)
# Test volread()
fname4 = get_remote_file("images/stent.npz", test_dir)
vol = imageio.volread(fname4)
assert vol.ndim == 3
assert vol.shape[0] == 256
assert vol.shape[1] == 128
assert vol.shape[2] == 128
# Test volsave()
volc = np.zeros((10, 10, 10, 3), np.uint8) # color volume
fname6 = os.path.join(test_dir, "images", "stent2.npz")
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.volsave(fname6, volc)
imageio.volsave(fname6, vol)
assert os.path.isfile(fname6)
# Test mvolread()
vols = imageio.mvolread(fname4)
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
# Test mvolsave()
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.mvolsave(fname6, [volc, volc])
imageio.mvolsave(fname6, vols)
assert os.path.isfile(fname6)
# Fail for save functions
raises(ValueError, imageio.imsave, fname2, np.zeros((100, 100, 5)))
raises(ValueError, imageio.imsave, fname2, 42)
raises(ValueError, imageio.mimsave, fname5, [np.zeros((100, 100, 5))])
raises(ValueError, imageio.mimsave, fname5, [42])
raises(ValueError, imageio.volsave, fname6, np.zeros((100, 100, 100, 40)))
raises(ValueError, imageio.volsave, fname6, 42)
raises(ValueError, imageio.mvolsave, fname6, [np.zeros((90, 90, 90, 40))])
raises(ValueError, imageio.mvolsave, fname6, [42])
def test_functions():
""" Test the user-facing API functions """
# Test help(), it prints stuff, so we just check whether that goes ok
imageio.help() # should print overview
imageio.help('PNG') # should print about PNG
fname1 = get_remote_file('images/chelsea.png', test_dir)
fname2 = fname1[:-3] + 'jpg'
fname3 = fname1[:-3] + 'notavalidext'
open(fname3, 'wb')
# Test read()
R1 = imageio.read(fname1)
R2 = imageio.read(fname1, 'png')
assert R1.format is R2.format
# Fail
raises(ValueError, imageio.read, fname3) # existing but not readable
raises(IOError, imageio.read, 'notexisting.barf')
raises(IndexError, imageio.read, fname1, 'notexistingformat')
# Test save()
W1 = imageio.save(fname2)
W2 = imageio.save(fname2, 'JPG')
assert W1.format is W2.format
# Fail
raises(ValueError, imageio.save, 'wtf.notexistingfile')
# Test imread()
im1 = imageio.imread(fname1)
im2 = imageio.imread(fname1, 'png')
assert im1.shape[2] == 3
assert np.all(im1 == im2)
# Test imsave()
if os.path.isfile(fname2):
os.remove(fname2)
assert not os.path.isfile(fname2)
imageio.imsave(fname2, im1[:, :, 0])
imageio.imsave(fname2, im1)
assert os.path.isfile(fname2)
# Test mimread()
fname3 = get_remote_file('images/newtonscradle.gif', test_dir)
ims = imageio.mimread(fname3)
assert isinstance(ims, list)
assert len(ims) > 1
assert ims[0].ndim == 3
assert ims[0].shape[2] in (1, 3, 4)
if IS_PYPY:
return # no support for npz format :(
# Test mimsave()
fname5 = fname3[:-4] + '2.npz'
if os.path.isfile(fname5):
os.remove(fname5)
assert not os.path.isfile(fname5)
imageio.mimsave(fname5, [im[:, :, 0] for im in ims])
imageio.mimsave(fname5, ims)
assert os.path.isfile(fname5)
# Test volread()
fname4 = get_remote_file('images/stent.npz', test_dir)
vol = imageio.volread(fname4)
assert vol.ndim == 3
assert vol.shape[0] == 256
assert vol.shape[1] == 128
assert vol.shape[2] == 128
# Test volsave()
volc = np.zeros((10, 10, 10, 3), np.uint8) # color volume
fname6 = fname4[:-4] + '2.npz'
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.volsave(fname6, volc)
imageio.volsave(fname6, vol)
assert os.path.isfile(fname6)
# Test mvolread()
vols = imageio.mvolread(fname4)
assert isinstance(vols, list)
assert len(vols) == 1
assert vols[0].shape == vol.shape
# Test mvolsave()
if os.path.isfile(fname6):
os.remove(fname6)
assert not os.path.isfile(fname6)
imageio.mvolsave(fname6, [volc, volc])
imageio.mvolsave(fname6, vols)
assert os.path.isfile(fname6)
# Fail for save functions
raises(ValueError, imageio.imsave, fname2, np.zeros((100, 100, 5)))
raises(ValueError, imageio.imsave, fname2, 42)
raises(ValueError, imageio.mimsave, fname5, [np.zeros((100, 100, 5))])
raises(ValueError, imageio.mimsave, fname5, [42])
raises(ValueError, imageio.volsave, fname4, np.zeros((100, 100, 100, 40)))
raises(ValueError, imageio.volsave, fname4, 42)
raises(ValueError, imageio.mvolsave, fname4, [np.zeros((90, 90, 90, 40))])
raises(ValueError, imageio.mvolsave, fname4, [42])
