def __call__(self, results):
"""Perform the FrameSelector selecting given indices.
Args:
results (dict): The resulting dict to be modified and passed
to the next transform in pipeline.
"""
mmcv.use_backend(self.decoding_backend)
directory = results['frame_dir']
filename_tmpl = results['filename_tmpl']
modality = results['modality']
if self.file_client is None:
self.file_client = FileClient(self.io_backend, **self.kwargs)
imgs = list()
if results['frame_inds'].ndim != 1:
results['frame_inds'] = np.squeeze(results['frame_inds'])
offset = results.get('offset', 0)
for frame_idx in results['frame_inds']:
frame_idx += offset
if modality == 'RGB':
filepath = osp.join(directory, filename_tmpl.format(frame_idx))
img_bytes = self.file_client.get(filepath)
# Get frame with channel order RGB directly.
cur_frame = mmcv.imfrombytes(img_bytes, channel_order='rgb')
imgs.append(cur_frame)
elif modality == 'Flow':
x_filepath = osp.join(directory,
filename_tmpl.format('x', frame_idx))
y_filepath = osp.join(directory,
filename_tmpl.format('y', frame_idx))
x_img_bytes = self.file_client.get(x_filepath)
x_frame = mmcv.imfrombytes(x_img_bytes, flag='grayscale')
y_img_bytes = self.file_client.get(y_filepath)
y_frame = mmcv.imfrombytes(y_img_bytes, flag='grayscale')
imgs.extend([x_frame, y_frame])
else:
raise NotImplementedError
results['imgs'] = imgs
results['original_shape'] = imgs[0].shape[:2]
results['img_shape'] = imgs[0].shape[:2]
return results
def test_imread(self):
# backend cv2
mmcv.use_backend('cv2')
img_cv2_color_bgr = mmcv.imread(self.img_path)
assert img_cv2_color_bgr.shape == (300, 400, 3)
img_cv2_color_rgb = mmcv.imread(self.img_path, channel_order='rgb')
assert img_cv2_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_cv2_color_rgb[:, :, ::-1], img_cv2_color_bgr)
img_cv2_grayscale1 = mmcv.imread(self.img_path, 'grayscale')
assert img_cv2_grayscale1.shape == (300, 400)
img_cv2_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_cv2_grayscale2.shape == (300, 400, 3)
img_cv2_unchanged = mmcv.imread(self.gray_img_path, 'unchanged')
assert img_cv2_unchanged.shape == (300, 400)
img_cv2_unchanged = mmcv.imread(img_cv2_unchanged)
assert_array_equal(img_cv2_unchanged, mmcv.imread(img_cv2_unchanged))
with pytest.raises(TypeError):
mmcv.imread(1)
# backend turbojpeg
mmcv.use_backend('turbojpeg')
img_turbojpeg_color_bgr = mmcv.imread(self.img_path)
assert img_turbojpeg_color_bgr.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_bgr, img_cv2_color_bgr)
img_turbojpeg_color_rgb = mmcv.imread(self.img_path,
channel_order='rgb')
assert img_turbojpeg_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_rgb, img_cv2_color_rgb)
with pytest.raises(ValueError):
mmcv.imread(self.img_path, channel_order='unsupport_order')
img_turbojpeg_grayscale1 = mmcv.imread(self.img_path, flag='grayscale')
assert img_turbojpeg_grayscale1.shape == (300, 400)
assert_array_equal(img_turbojpeg_grayscale1, img_cv2_grayscale1)
img_turbojpeg_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_turbojpeg_grayscale2.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_grayscale2, img_cv2_grayscale2)
img_turbojpeg_grayscale2 = mmcv.imread(img_turbojpeg_grayscale2)
assert_array_equal(img_turbojpeg_grayscale2,
mmcv.imread(img_turbojpeg_grayscale2))
with pytest.raises(ValueError):
mmcv.imread(self.gray_img_path, 'unchanged')
with pytest.raises(TypeError):
mmcv.imread(1)
with pytest.raises(AssertionError):
mmcv.use_backend('unsupport_backend')
mmcv.use_backend('cv2')
def test_imfrombytes(self):
# backend cv2
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_cv2 = mmcv.imfrombytes(img_bytes)
assert img_cv2.shape == (300, 400, 3)
# backend turbojpeg
mmcv.use_backend('turbojpeg')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_turbojpeg = mmcv.imfrombytes(img_bytes)
assert img_turbojpeg.shape == (300, 400, 3)
assert_array_equal(img_cv2, img_turbojpeg)
mmcv.use_backend('cv2')
def test_imread(self):
# backend cv2
mmcv.use_backend('cv2')
img_cv2_color_bgr = mmcv.imread(self.img_path)
assert img_cv2_color_bgr.shape == (300, 400, 3)
img_cv2_color_rgb = mmcv.imread(self.img_path, channel_order='rgb')
assert img_cv2_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_cv2_color_rgb[:, :, ::-1], img_cv2_color_bgr)
img_cv2_grayscale1 = mmcv.imread(self.img_path, 'grayscale')
assert img_cv2_grayscale1.shape == (300, 400)
img_cv2_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_cv2_grayscale2.shape == (300, 400, 3)
img_cv2_unchanged = mmcv.imread(self.gray_img_path, 'unchanged')
assert img_cv2_unchanged.shape == (300, 400)
img_cv2_unchanged = mmcv.imread(img_cv2_unchanged)
assert_array_equal(img_cv2_unchanged, mmcv.imread(img_cv2_unchanged))
img_cv2_color_bgr = mmcv.imread(self.img_path_obj)
assert img_cv2_color_bgr.shape == (300, 400, 3)
img_cv2_color_rgb = mmcv.imread(self.img_path_obj, channel_order='rgb')
assert img_cv2_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_cv2_color_rgb[:, :, ::-1], img_cv2_color_bgr)
img_cv2_grayscale1 = mmcv.imread(self.img_path_obj, 'grayscale')
assert img_cv2_grayscale1.shape == (300, 400)
img_cv2_grayscale2 = mmcv.imread(self.gray_img_path_obj)
assert img_cv2_grayscale2.shape == (300, 400, 3)
img_cv2_unchanged = mmcv.imread(self.gray_img_path_obj, 'unchanged')
assert img_cv2_unchanged.shape == (300, 400)
with pytest.raises(TypeError):
mmcv.imread(1)
# test arg backend pillow
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path,
'grayscale',
backend='pillow')
assert img_pil_gray_alpha.shape == (400, 500)
mean = img_pil_gray_alpha[300:, 400:].mean()
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path,
backend='pillow')
mean = img_pil_gray_alpha[300:, 400:].mean(axis=(0, 1))
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
assert img_pil_gray_alpha.shape == (400, 500, 3)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path,
'unchanged',
backend='pillow')
assert img_pil_gray_alpha.shape == (400, 500, 2)
img_pil_palette = mmcv.imread(self.palette_img_path,
'grayscale',
backend='pillow')
assert img_pil_palette.shape == (300, 400)
img_pil_palette = mmcv.imread(self.palette_img_path, backend='pillow')
assert img_pil_palette.shape == (300, 400, 3)
img_pil_palette = mmcv.imread(self.palette_img_path,
'unchanged',
backend='pillow')
assert img_pil_palette.shape == (300, 400)
# backend pillow
mmcv.use_backend('pillow')
img_pil_grayscale1 = mmcv.imread(self.img_path, 'grayscale')
assert img_pil_grayscale1.shape == (300, 400)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path, 'grayscale')
assert img_pil_gray_alpha.shape == (400, 500)
mean = img_pil_gray_alpha[300:, 400:].mean()
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path)
mean = img_pil_gray_alpha[300:, 400:].mean(axis=(0, 1))
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
assert img_pil_gray_alpha.shape == (400, 500, 3)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path, 'unchanged')
assert img_pil_gray_alpha.shape == (400, 500, 2)
img_pil_palette = mmcv.imread(self.palette_img_path, 'grayscale')
assert img_pil_palette.shape == (300, 400)
img_pil_palette = mmcv.imread(self.palette_img_path)
assert img_pil_palette.shape == (300, 400, 3)
img_pil_palette = mmcv.imread(self.palette_img_path, 'unchanged')
assert img_pil_palette.shape == (300, 400)
img_pil_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_pil_grayscale2.shape == (300, 400, 3)
img_pil_unchanged = mmcv.imread(self.gray_img_path, 'unchanged')
assert img_pil_unchanged.shape == (300, 400)
img_pil_unchanged = mmcv.imread(img_pil_unchanged)
assert_array_equal(img_pil_unchanged, mmcv.imread(img_pil_unchanged))
img_pil_color_bgr = mmcv.imread(self.img_path_obj)
assert img_pil_color_bgr.shape == (300, 400, 3)
img_pil_color_rgb = mmcv.imread(self.img_path_obj, channel_order='rgb')
assert img_pil_color_rgb.shape == (300, 400, 3)
assert (img_pil_color_rgb == img_cv2_color_rgb).sum() / float(
img_cv2_color_rgb.size) > 0.5
assert_array_equal(img_pil_color_rgb[:, :, ::-1], img_pil_color_bgr)
img_pil_grayscale1 = mmcv.imread(self.img_path_obj, 'grayscale')
assert img_pil_grayscale1.shape == (300, 400)
img_pil_grayscale2 = mmcv.imread(self.gray_img_path_obj)
assert img_pil_grayscale2.shape == (300, 400, 3)
img_pil_unchanged = mmcv.imread(self.gray_img_path_obj, 'unchanged')
assert img_pil_unchanged.shape == (300, 400)
with pytest.raises(TypeError):
mmcv.imread(1)
# backend turbojpeg
mmcv.use_backend('turbojpeg')
img_turbojpeg_color_bgr = mmcv.imread(self.img_path)
assert img_turbojpeg_color_bgr.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_bgr, img_cv2_color_bgr)
img_turbojpeg_color_rgb = mmcv.imread(self.img_path,
channel_order='rgb')
assert img_turbojpeg_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_rgb, img_cv2_color_rgb)
with pytest.raises(ValueError):
mmcv.imread(self.img_path, channel_order='unsupport_order')
img_turbojpeg_grayscale1 = mmcv.imread(self.img_path, flag='grayscale')
assert img_turbojpeg_grayscale1.shape == (300, 400)
assert_array_equal(img_turbojpeg_grayscale1, img_cv2_grayscale1)
img_turbojpeg_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_turbojpeg_grayscale2.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_grayscale2, img_cv2_grayscale2)
img_turbojpeg_grayscale2 = mmcv.imread(img_turbojpeg_grayscale2)
assert_array_equal(img_turbojpeg_grayscale2,
mmcv.imread(img_turbojpeg_grayscale2))
with pytest.raises(ValueError):
mmcv.imread(self.gray_img_path, 'unchanged')
with pytest.raises(TypeError):
mmcv.imread(1)
with pytest.raises(AssertionError):
mmcv.use_backend('unsupport_backend')
with pytest.raises(ValueError):
mmcv.imread(self.img_path, 'unsupported_backend')
# backend tifffile, multi channel tiff file(> 4 channels).
mmcv.use_backend('tifffile')
img_tifffile = mmcv.imread(self.tiff_path)
assert img_tifffile.shape == (200, 150, 5)
mmcv.use_backend('cv2')
# consistent exif behaviour
img_cv2_exif = mmcv.imread(self.exif_img_path)
img_pil_exif = mmcv.imread(self.exif_img_path, backend='pillow')
assert img_cv2_exif.shape == (400, 300, 3)
assert img_pil_exif.shape == (400, 300, 3)
img_cv2_exif_unchanged = mmcv.imread(self.exif_img_path,
flag='unchanged')
img_pil_exif_unchanged = mmcv.imread(self.exif_img_path,
backend='pillow',
flag='unchanged')
assert img_cv2_exif_unchanged.shape == (300, 400, 3)
assert img_pil_exif_unchanged.shape == (300, 400, 3)
img_cv2_color_ignore_exif = mmcv.imread(
self.exif_img_path, flag='color_ignore_orientation')
img_pil_color_ignore_exif = mmcv.imread(
self.exif_img_path,
backend='pillow',
flag='color_ignore_orientation')
assert img_cv2_color_ignore_exif.shape == (300, 400, 3)
assert img_pil_color_ignore_exif.shape == (300, 400, 3)
img_cv2_grayscale_ignore_exif = mmcv.imread(
self.exif_img_path, flag='grayscale_ignore_orientation')
img_pil_grayscale_ignore_exif = mmcv.imread(
self.exif_img_path,
backend='pillow',
flag='grayscale_ignore_orientation')
assert img_cv2_grayscale_ignore_exif.shape == (300, 400)
assert img_pil_grayscale_ignore_exif.shape == (300, 400)
def test_no_pillow(self):
with pytest.raises(ImportError):
mmcv.use_backend('pillow')
mmcv.use_backend('cv2')
def test_no_turbojpeg(self):
with pytest.raises(ImportError):
mmcv.use_backend('turbojpeg')
mmcv.use_backend('cv2')
def test_imfrombytes(self):
# backend cv2, channel order: bgr
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_cv2 = mmcv.imfrombytes(img_bytes)
assert img_cv2.shape == (300, 400, 3)
# backend cv2, channel order: rgb
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_rgb_cv2 = mmcv.imfrombytes(img_bytes, channel_order='rgb')
assert img_rgb_cv2.shape == (300, 400, 3)
assert_array_equal(img_rgb_cv2, img_cv2[:, :, ::-1])
# backend cv2, grayscale, decode as 3 channels
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_rgb_cv2 = mmcv.imfrombytes(img_bytes)
assert gray_img_rgb_cv2.shape == (300, 400, 3)
# backend cv2, grayscale
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_cv2 = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_cv2.shape == (300, 400)
# backend cv2, grayscale dim3
with open(self.gray_img_dim3_path, 'rb') as f:
img_bytes = f.read()
gray_img_dim3_cv2 = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_dim3_cv2.shape == (300, 400)
# arg backend pillow, channel order: bgr
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_pillow = mmcv.imfrombytes(img_bytes, backend='pillow')
assert img_pillow.shape == (300, 400, 3)
# Pillow and opencv decoding may not be the same
assert (img_cv2 == img_pillow).sum() / float(img_cv2.size) > 0.5
# backend pillow, channel order: bgr
mmcv.use_backend('pillow')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_pillow = mmcv.imfrombytes(img_bytes)
assert img_pillow.shape == (300, 400, 3)
# Pillow and opencv decoding may not be the same
assert (img_cv2 == img_pillow).sum() / float(img_cv2.size) > 0.5
# backend turbojpeg, channel order: bgr
mmcv.use_backend('turbojpeg')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_turbojpeg = mmcv.imfrombytes(img_bytes)
assert img_turbojpeg.shape == (300, 400, 3)
assert_array_equal(img_cv2, img_turbojpeg)
# backend turbojpeg, channel order: rgb
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_rgb_turbojpeg = mmcv.imfrombytes(img_bytes, channel_order='rgb')
assert img_rgb_turbojpeg.shape == (300, 400, 3)
assert_array_equal(img_rgb_turbojpeg, img_cv2[:, :, ::-1])
# backend turbojpeg, grayscale, decode as 3 channels
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_turbojpeg = mmcv.imfrombytes(img_bytes)
assert gray_img_turbojpeg.shape == (300, 400, 3)
assert_array_equal(gray_img_rgb_cv2, gray_img_turbojpeg)
# backend turbojpeg, grayscale
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_turbojpeg = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_turbojpeg.shape == (300, 400)
assert_array_equal(gray_img_cv2, gray_img_turbojpeg)
# backend turbojpeg, grayscale dim3
with open(self.gray_img_dim3_path, 'rb') as f:
img_bytes = f.read()
gray_img_dim3_turbojpeg = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_dim3_turbojpeg.shape == (300, 400)
assert_array_equal(gray_img_dim3_cv2, gray_img_dim3_turbojpeg)
mmcv.use_backend('cv2')
with pytest.raises(ValueError):
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
mmcv.imfrombytes(img_bytes, backend='unsupported_backend')
def test_imfrombytes(self):
# backend cv2, channel order: bgr
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_cv2 = mmcv.imfrombytes(img_bytes)
assert img_cv2.shape == (300, 400, 3)
# backend cv2, channel order: rgb
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_rgb_cv2 = mmcv.imfrombytes(img_bytes, channel_order='rgb')
assert img_rgb_cv2.shape == (300, 400, 3)
assert_array_equal(img_rgb_cv2, img_cv2[:, :, ::-1])
# backend cv2, grayscale, decode as 3 channels
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_rgb_cv2 = mmcv.imfrombytes(img_bytes)
assert gray_img_rgb_cv2.shape == (300, 400, 3)
# backend cv2, grayscale
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_cv2 = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_cv2.shape == (300, 400)
# backend cv2, grayscale dim3
with open(self.gray_img_dim3_path, 'rb') as f:
img_bytes = f.read()
gray_img_dim3_cv2 = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_dim3_cv2.shape == (300, 400)
# backend turbojpeg, channel order: bgr
mmcv.use_backend('turbojpeg')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_turbojpeg = mmcv.imfrombytes(img_bytes)
assert img_turbojpeg.shape == (300, 400, 3)
assert_array_equal(img_cv2, img_turbojpeg)
# backend turbojpeg, channel order: rgb
mmcv.use_backend('cv2')
with open(self.img_path, 'rb') as f:
img_bytes = f.read()
img_rgb_turbojpeg = mmcv.imfrombytes(img_bytes, channel_order='rgb')
assert img_rgb_turbojpeg.shape == (300, 400, 3)
assert_array_equal(img_rgb_turbojpeg, img_cv2[:, :, ::-1])
# backend turbojpeg, grayscale, decode as 3 channels
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_turbojpeg = mmcv.imfrombytes(img_bytes)
assert gray_img_turbojpeg.shape == (300, 400, 3)
assert_array_equal(gray_img_rgb_cv2, gray_img_turbojpeg)
# backend turbojpeg, grayscale
with open(self.gray_img_path, 'rb') as f:
img_bytes = f.read()
gray_img_turbojpeg = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_turbojpeg.shape == (300, 400)
assert_array_equal(gray_img_cv2, gray_img_turbojpeg)
# backend turbojpeg, grayscale dim3
with open(self.gray_img_dim3_path, 'rb') as f:
img_bytes = f.read()
gray_img_dim3_turbojpeg = mmcv.imfrombytes(img_bytes, flag='grayscale')
assert gray_img_dim3_turbojpeg.shape == (300, 400)
assert_array_equal(gray_img_dim3_cv2, gray_img_dim3_turbojpeg)
mmcv.use_backend('cv2')
def test_imread(self):
# backend cv2
mmcv.use_backend('cv2')
# HardDiskBackend
img_cv2_color_bgr = mmcv.imread(self.img_path)
assert img_cv2_color_bgr.shape == (300, 400, 3)
img_cv2_color_rgb = mmcv.imread(self.img_path, channel_order='rgb')
assert img_cv2_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_cv2_color_rgb[:, :, ::-1], img_cv2_color_bgr)
img_cv2_grayscale1 = mmcv.imread(self.img_path, 'grayscale')
assert img_cv2_grayscale1.shape == (300, 400)
img_cv2_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_cv2_grayscale2.shape == (300, 400, 3)
img_cv2_unchanged = mmcv.imread(self.gray_img_path, 'unchanged')
assert img_cv2_unchanged.shape == (300, 400)
img_cv2_unchanged = mmcv.imread(img_cv2_unchanged)
assert_array_equal(img_cv2_unchanged, mmcv.imread(img_cv2_unchanged))
img_cv2_color_bgr = mmcv.imread(self.img_path_obj)
assert img_cv2_color_bgr.shape == (300, 400, 3)
img_cv2_color_rgb = mmcv.imread(self.img_path_obj, channel_order='rgb')
assert img_cv2_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_cv2_color_rgb[:, :, ::-1], img_cv2_color_bgr)
img_cv2_grayscale1 = mmcv.imread(self.img_path_obj, 'grayscale')
assert img_cv2_grayscale1.shape == (300, 400)
img_cv2_grayscale2 = mmcv.imread(self.gray_img_path_obj)
assert img_cv2_grayscale2.shape == (300, 400, 3)
img_cv2_unchanged = mmcv.imread(self.gray_img_path_obj, 'unchanged')
assert img_cv2_unchanged.shape == (300, 400)
with pytest.raises(TypeError):
mmcv.imread(1)
# PetrelBackend
img_cv2_color_bgr = mmcv.imread(self.img_path)
with patch.object(
PetrelBackend, 'get',
return_value=img_cv2_color_bgr) as mock_method:
img_cv2_color_bgr_petrel = mmcv.imread(self.s3_path, backend='cv2')
img_cv2_color_bgr_petrel_with_args = mmcv.imread(
self.s3_path,
backend='cv2',
file_client_args={'backend': 'petrel'})
mock_method.assert_called()
assert_array_equal(img_cv2_color_bgr_petrel,
img_cv2_color_bgr_petrel_with_args)
# HTTPBackend
img_cv2_color_bgr = mmcv.imread(self.img_path)
with patch.object(
HTTPBackend, 'get',
return_value=img_cv2_color_bgr) as mock_method:
img_cv2_color_bgr_http = mmcv.imread(self.http_path, backend='cv2')
img_cv2_color_bgr_http_with_args = mmcv.imread(
self.http_path,
backend='cv2',
file_client_args={'backend': 'http'})
mock_method.assert_called()
assert_array_equal(img_cv2_color_bgr_http,
img_cv2_color_bgr_http_with_args)
with pytest.raises(FileNotFoundError):
mmcv.imread('/not/exists/' + self.img_path)
# test arg backend pillow
img_pil_gray_alpha = mmcv.imread(
self.gray_alpha_img_path, 'grayscale', backend='pillow')
assert img_pil_gray_alpha.shape == (400, 500)
mean = img_pil_gray_alpha[300:, 400:].mean()
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
img_pil_gray_alpha = mmcv.imread(
self.gray_alpha_img_path, backend='pillow')
mean = img_pil_gray_alpha[300:, 400:].mean(axis=(0, 1))
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
assert img_pil_gray_alpha.shape == (400, 500, 3)
img_pil_gray_alpha = mmcv.imread(
self.gray_alpha_img_path, 'unchanged', backend='pillow')
assert img_pil_gray_alpha.shape == (400, 500, 2)
img_pil_palette = mmcv.imread(
self.palette_img_path, 'grayscale', backend='pillow')
assert img_pil_palette.shape == (300, 400)
img_pil_palette = mmcv.imread(self.palette_img_path, backend='pillow')
assert img_pil_palette.shape == (300, 400, 3)
img_pil_palette = mmcv.imread(
self.palette_img_path, 'unchanged', backend='pillow')
assert img_pil_palette.shape == (300, 400)
# backend pillow
mmcv.use_backend('pillow')
img_pil_grayscale1 = mmcv.imread(self.img_path, 'grayscale')
assert img_pil_grayscale1.shape == (300, 400)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path, 'grayscale')
assert img_pil_gray_alpha.shape == (400, 500)
mean = img_pil_gray_alpha[300:, 400:].mean()
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path)
mean = img_pil_gray_alpha[300:, 400:].mean(axis=(0, 1))
assert_allclose(img_pil_gray_alpha[300:, 400:] - mean, 0)
assert img_pil_gray_alpha.shape == (400, 500, 3)
img_pil_gray_alpha = mmcv.imread(self.gray_alpha_img_path, 'unchanged')
assert img_pil_gray_alpha.shape == (400, 500, 2)
img_pil_palette = mmcv.imread(self.palette_img_path, 'grayscale')
assert img_pil_palette.shape == (300, 400)
img_pil_palette = mmcv.imread(self.palette_img_path)
assert img_pil_palette.shape == (300, 400, 3)
img_pil_palette = mmcv.imread(self.palette_img_path, 'unchanged')
assert img_pil_palette.shape == (300, 400)
img_pil_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_pil_grayscale2.shape == (300, 400, 3)
img_pil_unchanged = mmcv.imread(self.gray_img_path, 'unchanged')
assert img_pil_unchanged.shape == (300, 400)
img_pil_unchanged = mmcv.imread(img_pil_unchanged)
assert_array_equal(img_pil_unchanged, mmcv.imread(img_pil_unchanged))
img_pil_color_bgr = mmcv.imread(self.img_path_obj)
assert img_pil_color_bgr.shape == (300, 400, 3)
img_pil_color_rgb = mmcv.imread(self.img_path_obj, channel_order='rgb')
assert img_pil_color_rgb.shape == (300, 400, 3)
assert (img_pil_color_rgb == img_cv2_color_rgb).sum() / float(
img_cv2_color_rgb.size) > 0.5
assert_array_equal(img_pil_color_rgb[:, :, ::-1], img_pil_color_bgr)
img_pil_grayscale1 = mmcv.imread(self.img_path_obj, 'grayscale')
assert img_pil_grayscale1.shape == (300, 400)
img_pil_grayscale2 = mmcv.imread(self.gray_img_path_obj)
assert img_pil_grayscale2.shape == (300, 400, 3)
img_pil_unchanged = mmcv.imread(self.gray_img_path_obj, 'unchanged')
assert img_pil_unchanged.shape == (300, 400)
with pytest.raises(TypeError):
mmcv.imread(1)
# backend turbojpeg
mmcv.use_backend('turbojpeg')
img_turbojpeg_color_bgr = mmcv.imread(self.img_path)
assert img_turbojpeg_color_bgr.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_bgr, img_cv2_color_bgr)
img_turbojpeg_color_rgb = mmcv.imread(
self.img_path, channel_order='rgb')
assert img_turbojpeg_color_rgb.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_color_rgb, img_cv2_color_rgb)
with pytest.raises(ValueError):
mmcv.imread(self.img_path, channel_order='unsupport_order')
img_turbojpeg_grayscale1 = mmcv.imread(self.img_path, flag='grayscale')
assert img_turbojpeg_grayscale1.shape == (300, 400)
assert_array_equal(img_turbojpeg_grayscale1, img_cv2_grayscale1)
img_turbojpeg_grayscale2 = mmcv.imread(self.gray_img_path)
assert img_turbojpeg_grayscale2.shape == (300, 400, 3)
assert_array_equal(img_turbojpeg_grayscale2, img_cv2_grayscale2)
img_turbojpeg_grayscale2 = mmcv.imread(img_turbojpeg_grayscale2)
assert_array_equal(img_turbojpeg_grayscale2,
mmcv.imread(img_turbojpeg_grayscale2))
with pytest.raises(ValueError):
mmcv.imread(self.gray_img_path, 'unchanged')
with pytest.raises(TypeError):
mmcv.imread(1)
with pytest.raises(AssertionError):
mmcv.use_backend('unsupport_backend')
with pytest.raises(ValueError):
mmcv.imread(self.img_path, 'unsupported_backend')
# backend tifffile, multi channel tiff file(> 4 channels).
mmcv.use_backend('tifffile')
img_tifffile = mmcv.imread(self.tiff_path)
assert img_tifffile.shape == (200, 150, 5)
mmcv.use_backend('cv2')
# consistent exif behaviour
img_cv2_exif = mmcv.imread(self.exif_img_path)
img_pil_exif = mmcv.imread(self.exif_img_path, backend='pillow')
assert img_cv2_exif.shape == (400, 300, 3)
assert img_pil_exif.shape == (400, 300, 3)
img_cv2_exif_unchanged = mmcv.imread(
self.exif_img_path, flag='unchanged')
img_pil_exif_unchanged = mmcv.imread(
self.exif_img_path, backend='pillow', flag='unchanged')
assert img_cv2_exif_unchanged.shape == (300, 400, 3)
assert img_pil_exif_unchanged.shape == (300, 400, 3)
img_cv2_color_ignore_exif = mmcv.imread(
self.exif_img_path, flag='color_ignore_orientation')
img_pil_color_ignore_exif = mmcv.imread(
self.exif_img_path,
backend='pillow',
flag='color_ignore_orientation')
assert img_cv2_color_ignore_exif.shape == (300, 400, 3)
assert img_pil_color_ignore_exif.shape == (300, 400, 3)
img_cv2_grayscale_ignore_exif = mmcv.imread(
self.exif_img_path, flag='grayscale_ignore_orientation')
img_pil_grayscale_ignore_exif = mmcv.imread(
self.exif_img_path,
backend='pillow',
flag='grayscale_ignore_orientation')
assert img_cv2_grayscale_ignore_exif.shape == (300, 400)
assert img_pil_grayscale_ignore_exif.shape == (300, 400)
