未验证 提交 6ab43f7f 编写于 作者: W Wenyu 提交者: GitHub

Support transforms for paddle tensor image (#31970)

* add to_grayscale, normalize

* add rotate

* add vfip and hflip

* add crop center_crop


* add padding, support constant, reflect, replicate, circular same as paddle.pad

* add get-image-[n,c,w,h] axis utils
上级 c6713bc0
...@@ -56,7 +56,10 @@ class TestTransformsCV2(unittest.TestCase): ...@@ -56,7 +56,10 @@ class TestTransformsCV2(unittest.TestCase):
'uint8')) 'uint8'))
def get_shape(self, img): def get_shape(self, img):
if self.backend == 'pil': if isinstance(img, paddle.Tensor):
return img.shape
elif self.backend == 'pil':
return np.array(img).shape return np.array(img).shape
return img.shape return img.shape
...@@ -253,6 +256,22 @@ class TestTransformsCV2(unittest.TestCase): ...@@ -253,6 +256,22 @@ class TestTransformsCV2(unittest.TestCase):
fake_img = self.create_image((100, 120, 3)) fake_img = self.create_image((100, 120, 3))
F.pad(fake_img, [1.0, 2.0, 3.0]) F.pad(fake_img, [1.0, 2.0, 3.0])
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, '1')
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, 1, {})
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, 1, padding_mode=-1)
with self.assertRaises(ValueError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, [1.0, 2.0, 3.0])
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
transforms.RandomRotation(-2) transforms.RandomRotation(-2)
...@@ -290,6 +309,159 @@ class TestTransformsPIL(TestTransformsCV2): ...@@ -290,6 +309,159 @@ class TestTransformsPIL(TestTransformsCV2):
return 'pil' return 'pil'
class TestTransformsTensor(TestTransformsCV2):
def get_backend(self):
return 'tensor'
def create_image(self, shape):
return paddle.to_tensor(np.random.rand(*shape)).transpose(
(2, 0, 1)) # hwc->chw
def do_transform(self, trans):
trans.transforms.insert(0, transforms.ToTensor(data_format='CHW'))
trans.transforms.append(transforms.Transpose(order=(1, 2, 0)))
dataset_folder = DatasetFolder(self.data_dir, transform=trans)
for _ in dataset_folder:
pass
def test_trans_all(self):
normalize = transforms.Normalize(
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.120, 57.375], )
trans = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
normalize,
])
self.do_transform(trans)
def test_grayscale(self):
trans = transforms.Compose([transforms.Grayscale()])
self.do_transform(trans)
trans_gray = transforms.Grayscale()
fake_img = self.create_image((500, 400, 3))
fake_img_gray = trans_gray(fake_img)
np.testing.assert_equal(self.get_shape(fake_img_gray)[1], 500)
np.testing.assert_equal(self.get_shape(fake_img_gray)[2], 400)
trans_gray3 = transforms.Grayscale(3)
fake_img = self.create_image((500, 400, 3))
fake_img_gray = trans_gray3(fake_img)
def test_normalize(self):
normalize = transforms.Normalize(mean=0.5, std=0.5)
trans = transforms.Compose([normalize])
self.do_transform(trans)
def test_pad(self):
trans = transforms.Compose([transforms.Pad(2)])
self.do_transform(trans)
fake_img = self.create_image((200, 150, 3))
trans_pad = transforms.Compose([transforms.Pad(10)])
fake_img_padded = trans_pad(fake_img)
np.testing.assert_equal(self.get_shape(fake_img_padded), (3, 220, 170))
trans_pad1 = transforms.Pad([1, 2])
trans_pad2 = transforms.Pad([1, 2, 3, 4])
trans_pad4 = transforms.Pad(1, padding_mode='edge')
img = trans_pad1(fake_img)
img = trans_pad2(img)
img = trans_pad4(img)
def test_random_crop(self):
trans = transforms.Compose([
transforms.RandomCrop(200),
transforms.RandomCrop((140, 160)),
])
self.do_transform(trans)
trans_random_crop1 = transforms.RandomCrop(224)
trans_random_crop2 = transforms.RandomCrop((140, 160))
fake_img = self.create_image((500, 400, 3))
fake_img_crop1 = trans_random_crop1(fake_img)
fake_img_crop2 = trans_random_crop2(fake_img_crop1)
np.testing.assert_equal(self.get_shape(fake_img_crop1), (3, 224, 224))
np.testing.assert_equal(self.get_shape(fake_img_crop2), (3, 140, 160))
trans_random_crop_same = transforms.RandomCrop((140, 160))
img = trans_random_crop_same(fake_img_crop2)
trans_random_crop_bigger = transforms.RandomCrop(
(180, 200), pad_if_needed=True)
img = trans_random_crop_bigger(img)
trans_random_crop_pad = transforms.RandomCrop((224, 256), 2, True)
img = trans_random_crop_pad(img)
def test_exception(self):
trans = transforms.Compose([transforms.Resize(-1)])
trans_batch = transforms.Compose([transforms.Resize(-1)])
with self.assertRaises(Exception):
self.do_transform(trans)
with self.assertRaises(Exception):
self.do_transform(trans_batch)
with self.assertRaises(ValueError):
transforms.Pad([1.0, 2.0, 3.0])
with self.assertRaises(TypeError):
fake_img = self.create_image((100, 120, 3))
F.pad(fake_img, '1')
with self.assertRaises(TypeError):
fake_img = self.create_image((100, 120, 3))
F.pad(fake_img, 1, {})
with self.assertRaises(TypeError):
fake_img = self.create_image((100, 120, 3))
F.pad(fake_img, 1, padding_mode=-1)
with self.assertRaises(ValueError):
fake_img = self.create_image((100, 120, 3))
F.pad(fake_img, [1.0, 2.0, 3.0])
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, '1')
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, 1, {})
with self.assertRaises(TypeError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, 1, padding_mode=-1)
with self.assertRaises(ValueError):
tensor_img = paddle.rand((3, 100, 100))
F.pad(tensor_img, [1.0, 2.0, 3.0])
with self.assertRaises(ValueError):
transforms.RandomRotation(-2)
with self.assertRaises(ValueError):
transforms.RandomRotation([1, 2, 3])
with self.assertRaises(ValueError):
trans_gray = transforms.Grayscale(5)
fake_img = self.create_image((100, 120, 3))
trans_gray(fake_img)
with self.assertRaises(TypeError):
transform = transforms.RandomResizedCrop(64)
transform(1)
test_color_jitter = None
class TestFunctional(unittest.TestCase): class TestFunctional(unittest.TestCase):
def test_errors(self): def test_errors(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
...@@ -300,6 +472,14 @@ class TestFunctional(unittest.TestCase): ...@@ -300,6 +472,14 @@ class TestFunctional(unittest.TestCase):
'uint8')) 'uint8'))
F.to_tensor(fake_img, data_format=1) F.to_tensor(fake_img, data_format=1)
with self.assertRaises(ValueError):
fake_img = paddle.rand((3, 100, 100))
F.pad(fake_img, 1, padding_mode='symmetric')
with self.assertRaises(TypeError):
fake_img = paddle.rand((3, 100, 100))
F.resize(fake_img, {1: 1})
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
fake_img = Image.fromarray((np.random.rand(28, 28, 3) * 255).astype( fake_img = Image.fromarray((np.random.rand(28, 28, 3) * 255).astype(
'uint8')) 'uint8'))
...@@ -354,31 +534,50 @@ class TestFunctional(unittest.TestCase): ...@@ -354,31 +534,50 @@ class TestFunctional(unittest.TestCase):
std = [0.5, 0.5, 0.5] std = [0.5, 0.5, 0.5]
normalized_img = F.normalize(tensor_img, mean, std) normalized_img = F.normalize(tensor_img, mean, std)
normalized_img = F.normalize( normalized_img_tensor = F.normalize(
tensor_img_hwc, mean, std, data_format='HWC') tensor_img_hwc, mean, std, data_format='HWC')
normalized_img = F.normalize(pil_img, mean, std, data_format='HWC') normalized_img_pil = F.normalize(pil_img, mean, std, data_format='HWC')
normalized_img = F.normalize( normalized_img_np = F.normalize(
np_img, mean, std, data_format='HWC', to_rgb=True) np_img, mean, std, data_format='HWC', to_rgb=True)
np.testing.assert_almost_equal(
np.array(normalized_img_pil), normalized_img_np)
np.testing.assert_almost_equal(normalized_img_tensor.numpy(),
normalized_img_np)
def test_center_crop(self): def test_center_crop(self):
np_img = (np.random.rand(28, 24, 3)).astype('uint8') np_img = (np.random.rand(28, 24, 3)).astype('uint8')
pil_img = Image.fromarray(np_img) pil_img = Image.fromarray(np_img)
tensor_img = F.to_tensor(pil_img, data_format='CHW')
np_cropped_img = F.center_crop(np_img, 4) np_cropped_img = F.center_crop(np_img, 4)
pil_cropped_img = F.center_crop(pil_img, 4) pil_cropped_img = F.center_crop(pil_img, 4)
tensor_cropped_img = F.center_crop(tensor_img, 4)
np.testing.assert_almost_equal(np_cropped_img, np.testing.assert_almost_equal(np_cropped_img,
np.array(pil_cropped_img)) np.array(pil_cropped_img))
np.testing.assert_almost_equal(np_cropped_img,
tensor_cropped_img.numpy().transpose(
(1, 2, 0)))
def test_pad(self): def test_pad(self):
np_img = (np.random.rand(28, 24, 3)).astype('uint8') np_img = (np.random.rand(28, 24, 3)).astype('uint8')
pil_img = Image.fromarray(np_img) pil_img = Image.fromarray(np_img)
tensor_img = F.to_tensor(pil_img, 'CHW')
np_padded_img = F.pad(np_img, [1, 2], padding_mode='reflect') np_padded_img = F.pad(np_img, [1, 2], padding_mode='reflect')
pil_padded_img = F.pad(pil_img, [1, 2], padding_mode='reflect') pil_padded_img = F.pad(pil_img, [1, 2], padding_mode='reflect')
tensor_padded_img = F.pad(tensor_img, [1, 2], padding_mode='reflect')
np.testing.assert_almost_equal(np_padded_img, np.array(pil_padded_img)) np.testing.assert_almost_equal(np_padded_img, np.array(pil_padded_img))
np.testing.assert_almost_equal(np_padded_img,
tensor_padded_img.numpy().transpose(
(1, 2, 0)))
tensor_padded_img = F.pad(tensor_img, 1, padding_mode='reflect')
tensor_padded_img = F.pad(tensor_img, [1, 2, 1, 2],
padding_mode='reflect')
pil_p_img = pil_img.convert('P') pil_p_img = pil_img.convert('P')
pil_padded_img = F.pad(pil_p_img, [1, 2]) pil_padded_img = F.pad(pil_p_img, [1, 2])
...@@ -387,12 +586,21 @@ class TestFunctional(unittest.TestCase): ...@@ -387,12 +586,21 @@ class TestFunctional(unittest.TestCase):
def test_resize(self): def test_resize(self):
np_img = (np.zeros([28, 24, 3])).astype('uint8') np_img = (np.zeros([28, 24, 3])).astype('uint8')
pil_img = Image.fromarray(np_img) pil_img = Image.fromarray(np_img)
tensor_img = F.to_tensor(pil_img, 'CHW')
np_reseized_img = F.resize(np_img, 40) np_reseized_img = F.resize(np_img, 40)
pil_reseized_img = F.resize(pil_img, 40) pil_reseized_img = F.resize(pil_img, 40)
tensor_reseized_img = F.resize(tensor_img, 40)
tensor_reseized_img2 = F.resize(tensor_img, (46, 40))
np.testing.assert_almost_equal(np_reseized_img, np.testing.assert_almost_equal(np_reseized_img,
np.array(pil_reseized_img)) np.array(pil_reseized_img))
np.testing.assert_almost_equal(np_reseized_img,
tensor_reseized_img.numpy().transpose(
(1, 2, 0)))
np.testing.assert_almost_equal(np_reseized_img,
tensor_reseized_img2.numpy().transpose(
(1, 2, 0)))
gray_img = (np.zeros([28, 32])).astype('uint8') gray_img = (np.zeros([28, 32])).astype('uint8')
gray_resize_img = F.resize(gray_img, 40) gray_resize_img = F.resize(gray_img, 40)
...@@ -447,12 +655,24 @@ class TestFunctional(unittest.TestCase): ...@@ -447,12 +655,24 @@ class TestFunctional(unittest.TestCase):
def test_rotate(self): def test_rotate(self):
np_img = (np.random.rand(28, 28, 3) * 255).astype('uint8') np_img = (np.random.rand(28, 28, 3) * 255).astype('uint8')
pil_img = Image.fromarray(np_img).convert('RGB') pil_img = Image.fromarray(np_img).convert('RGB')
rotated_np_img = F.rotate(np_img, 80, expand=True) rotated_np_img = F.rotate(np_img, 80, expand=True)
rotated_pil_img = F.rotate(pil_img, 80, expand=True) rotated_pil_img = F.rotate(pil_img, 80, expand=True)
tensor_img = F.to_tensor(pil_img, 'CHW')
rotated_tensor_img1 = F.rotate(tensor_img, 80, expand=True)
rotated_tensor_img2 = F.rotate(
tensor_img,
80,
interpolation='bilinear',
center=(10, 10),
expand=False)
np.testing.assert_equal(rotated_np_img.shape, np.testing.assert_equal(rotated_np_img.shape,
np.array(rotated_pil_img).shape) np.array(rotated_pil_img).shape)
np.testing.assert_equal(rotated_np_img.shape,
rotated_tensor_img1.transpose((1, 2, 0)).shape)
def test_rotate1(self): def test_rotate1(self):
np_img = (np.random.rand(28, 28, 3) * 255).astype('uint8') np_img = (np.random.rand(28, 28, 3) * 255).astype('uint8')
......
...@@ -80,9 +80,9 @@ def set_image_backend(backend): ...@@ -80,9 +80,9 @@ def set_image_backend(backend):
shutil.rmtree(temp_dir) shutil.rmtree(temp_dir)
""" """
global _image_backend global _image_backend
if backend not in ['pil', 'cv2']: if backend not in ['pil', 'cv2', 'tensor']:
raise ValueError( raise ValueError(
"Expected backend are one of ['pil', 'cv2'], but got {}" "Expected backend are one of ['pil', 'cv2', 'tensor'], but got {}"
.format(backend)) .format(backend))
_image_backend = backend _image_backend = backend
...@@ -150,13 +150,13 @@ def image_load(path, backend=None): ...@@ -150,13 +150,13 @@ def image_load(path, backend=None):
if backend is None: if backend is None:
backend = _image_backend backend = _image_backend
if backend not in ['pil', 'cv2']: if backend not in ['pil', 'cv2', 'tensor']:
raise ValueError( raise ValueError(
"Expected backend are one of ['pil', 'cv2'], but got {}" "Expected backend are one of ['pil', 'cv2', 'tensor'], but got {}"
.format(backend)) .format(backend))
if backend == 'pil': if backend == 'pil':
return Image.open(path) return Image.open(path)
else: elif backend == 'cv2':
cv2 = try_import('cv2') cv2 = try_import('cv2')
return cv2.imread(path) return cv2.imread(path)
...@@ -25,13 +25,6 @@ from PIL import Image ...@@ -25,13 +25,6 @@ from PIL import Image
from numpy import sin, cos, tan from numpy import sin, cos, tan
import paddle import paddle
if sys.version_info < (3, 3):
Sequence = collections.Sequence
Iterable = collections.Iterable
else:
Sequence = collections.abc.Sequence
Iterable = collections.abc.Iterable
from . import functional_pil as F_pil from . import functional_pil as F_pil
from . import functional_cv2 as F_cv2 from . import functional_cv2 as F_cv2
from . import functional_tensor as F_t from . import functional_tensor as F_t
...@@ -83,14 +76,18 @@ def to_tensor(pic, data_format='CHW'): ...@@ -83,14 +76,18 @@ def to_tensor(pic, data_format='CHW'):
print(tensor.shape) print(tensor.shape)
""" """
if not (_is_pil_image(pic) or _is_numpy_image(pic)): if not (_is_pil_image(pic) or _is_numpy_image(pic) or
raise TypeError('pic should be PIL Image or ndarray. Got {}'.format( _is_tensor_image(pic)):
type(pic))) raise TypeError(
'pic should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(pic)))
if _is_pil_image(pic): if _is_pil_image(pic):
return F_pil.to_tensor(pic, data_format) return F_pil.to_tensor(pic, data_format)
else: elif _is_numpy_image(pic):
return F_cv2.to_tensor(pic, data_format) return F_cv2.to_tensor(pic, data_format)
else:
return pic if data_format.lower() == 'chw' else pic.transpose((1, 2, 0))
def resize(img, size, interpolation='bilinear'): def resize(img, size, interpolation='bilinear'):
...@@ -135,13 +132,16 @@ def resize(img, size, interpolation='bilinear'): ...@@ -135,13 +132,16 @@ def resize(img, size, interpolation='bilinear'):
converted_img = F.resize(fake_img, (200, 150)) converted_img = F.resize(fake_img, (200, 150))
print(converted_img.size) print(converted_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.resize(img, size, interpolation) return F_pil.resize(img, size, interpolation)
elif _is_tensor_image(img):
return F_t.resize(img, size, interpolation)
else: else:
return F_cv2.resize(img, size, interpolation) return F_cv2.resize(img, size, interpolation)
...@@ -196,13 +196,16 @@ def pad(img, padding, fill=0, padding_mode='constant'): ...@@ -196,13 +196,16 @@ def pad(img, padding, fill=0, padding_mode='constant'):
padded_img = F.pad(fake_img, padding=(2, 1)) padded_img = F.pad(fake_img, padding=(2, 1))
print(padded_img.size) print(padded_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.pad(img, padding, fill, padding_mode) return F_pil.pad(img, padding, fill, padding_mode)
elif _is_tensor_image(img):
return F_t.pad(img, padding, fill, padding_mode)
else: else:
return F_cv2.pad(img, padding, fill, padding_mode) return F_cv2.pad(img, padding, fill, padding_mode)
...@@ -236,13 +239,16 @@ def crop(img, top, left, height, width): ...@@ -236,13 +239,16 @@ def crop(img, top, left, height, width):
print(cropped_img.size) print(cropped_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.crop(img, top, left, height, width) return F_pil.crop(img, top, left, height, width)
elif _is_tensor_image(img):
return F_t.crop(img, top, left, height, width)
else: else:
return F_cv2.crop(img, top, left, height, width) return F_cv2.crop(img, top, left, height, width)
...@@ -272,13 +278,16 @@ def center_crop(img, output_size): ...@@ -272,13 +278,16 @@ def center_crop(img, output_size):
cropped_img = F.center_crop(fake_img, (150, 100)) cropped_img = F.center_crop(fake_img, (150, 100))
print(cropped_img.size) print(cropped_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.center_crop(img, output_size) return F_pil.center_crop(img, output_size)
elif _is_tensor_image(img):
return F_t.center_crop(img, output_size)
else: else:
return F_cv2.center_crop(img, output_size) return F_cv2.center_crop(img, output_size)
...@@ -307,13 +316,16 @@ def hflip(img): ...@@ -307,13 +316,16 @@ def hflip(img):
print(flpped_img.size) print(flpped_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.hflip(img) return F_pil.hflip(img)
elif _is_tensor_image(img):
return F_t.hflip(img)
else: else:
return F_cv2.hflip(img) return F_cv2.hflip(img)
...@@ -342,13 +354,16 @@ def vflip(img): ...@@ -342,13 +354,16 @@ def vflip(img):
print(flpped_img.size) print(flpped_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.vflip(img) return F_pil.vflip(img)
elif _is_tensor_image(img):
return F_t.vflip(img)
else: else:
return F_cv2.vflip(img) return F_cv2.vflip(img)
...@@ -563,9 +578,10 @@ def rotate(img, ...@@ -563,9 +578,10 @@ def rotate(img,
print(rotated_img.size) print(rotated_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if isinstance(center, list): if isinstance(center, list):
...@@ -575,6 +591,8 @@ def rotate(img, ...@@ -575,6 +591,8 @@ def rotate(img,
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.rotate(img, angle, interpolation, expand, center, fill) return F_pil.rotate(img, angle, interpolation, expand, center, fill)
elif _is_tensor_image(img):
return F_t.rotate(img, angle, interpolation, expand, center, fill)
else: else:
return F_cv2.rotate(img, angle, interpolation, expand, center, fill) return F_cv2.rotate(img, angle, interpolation, expand, center, fill)
...@@ -606,13 +624,16 @@ def to_grayscale(img, num_output_channels=1): ...@@ -606,13 +624,16 @@ def to_grayscale(img, num_output_channels=1):
print(gray_img.size) print(gray_img.size)
""" """
if not (_is_pil_image(img) or _is_numpy_image(img)): if not (_is_pil_image(img) or _is_numpy_image(img) or
_is_tensor_image(img)):
raise TypeError( raise TypeError(
'img should be PIL Image or ndarray with dim=[2 or 3]. Got {}'. 'img should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}'.
format(type(img))) format(type(img)))
if _is_pil_image(img): if _is_pil_image(img):
return F_pil.to_grayscale(img, num_output_channels) return F_pil.to_grayscale(img, num_output_channels)
elif _is_tensor_image(img):
return F_t.to_grayscale(img, num_output_channels)
else: else:
return F_cv2.to_grayscale(img, num_output_channels) return F_cv2.to_grayscale(img, num_output_channels)
......
...@@ -14,11 +14,78 @@ ...@@ -14,11 +14,78 @@
from __future__ import division from __future__ import division
import math
import numbers
import paddle import paddle
import paddle.nn.functional as F
import sys
import collections
def _assert_image_tensor(img, data_format):
if not isinstance(
img, paddle.Tensor) or img.ndim != 3 or not data_format.lower() in (
'chw', 'hwc'):
raise RuntimeError(
'not support [type={}, ndim={}, data_format={}] paddle image'.
format(type(img), img.ndim, data_format))
def _get_image_h_axis(data_format):
if data_format.lower() == 'chw':
return -2
elif data_format.lower() == 'hwc':
return -3
def _get_image_w_axis(data_format):
if data_format.lower() == 'chw':
return -1
elif data_format.lower() == 'hwc':
return -2
def _get_image_c_axis(data_format):
if data_format.lower() == 'chw':
return -3
elif data_format.lower() == 'hwc':
return -1
def _get_image_n_axis(data_format):
if len(data_format) == 3:
return None
elif len(data_format) == 4:
return 0
def _is_channel_last(data_format):
return _get_image_c_axis(data_format) == -1
def _is_channel_first(data_format):
return _get_image_c_axis(data_format) == -3
def _get_image_num_batches(img, data_format):
if _get_image_n_axis(data_format):
return img.shape[_get_image_n_axis(data_format)]
return None
def _get_image_num_channels(img, data_format):
return img.shape[_get_image_c_axis(data_format)]
def _get_image_size(img, data_format):
return img.shape[_get_image_w_axis(data_format)], img.shape[
_get_image_h_axis(data_format)]
def normalize(img, mean, std, data_format='CHW'): def normalize(img, mean, std, data_format='CHW'):
"""Normalizes a tensor image with mean and standard deviation. """Normalizes a tensor image given mean and standard deviation.
Args: Args:
img (paddle.Tensor): input data to be normalized. img (paddle.Tensor): input data to be normalized.
...@@ -31,10 +98,417 @@ def normalize(img, mean, std, data_format='CHW'): ...@@ -31,10 +98,417 @@ def normalize(img, mean, std, data_format='CHW'):
Tensor: Normalized mage. Tensor: Normalized mage.
""" """
if data_format == 'CHW': _assert_image_tensor(img, data_format)
mean = paddle.to_tensor(mean).reshape([-1, 1, 1])
std = paddle.to_tensor(std).reshape([-1, 1, 1]) mean = paddle.to_tensor(mean, place=img.place)
else: std = paddle.to_tensor(std, place=img.place)
mean = paddle.to_tensor(mean)
std = paddle.to_tensor(std) if _is_channel_first(data_format):
mean = mean.reshape([-1, 1, 1])
std = std.reshape([-1, 1, 1])
return (img - mean) / std return (img - mean) / std
def to_grayscale(img, num_output_channels=1, data_format='CHW'):
"""Converts image to grayscale version of image.
Args:
img (paddel.Tensor): Image to be converted to grayscale.
num_output_channels (int, optionl[1, 3]):
if num_output_channels = 1 : returned image is single channel
if num_output_channels = 3 : returned image is 3 channel
data_format (str, optional): Data format of img, should be 'HWC' or
'CHW'. Default: 'CHW'.
Returns:
paddle.Tensor: Grayscale version of the image.
"""
_assert_image_tensor(img, data_format)
if num_output_channels not in (1, 3):
raise ValueError('num_output_channels should be either 1 or 3')
rgb_weights = paddle.to_tensor(
[0.2989, 0.5870, 0.1140], place=img.place).astype(img.dtype)
if _is_channel_first(data_format):
rgb_weights = rgb_weights.reshape((-1, 1, 1))
_c_index = _get_image_c_axis(data_format)
img = (img * rgb_weights).sum(axis=_c_index, keepdim=True)
_shape = img.shape
_shape[_c_index] = num_output_channels
return img.expand(_shape)
def _affine_grid(theta, w, h, ow, oh):
d = 0.5
base_grid = paddle.ones((1, oh, ow, 3), dtype=theta.dtype)
x_grid = paddle.linspace(-ow * 0.5 + d, ow * 0.5 + d - 1, ow)
base_grid[..., 0] = x_grid
y_grid = paddle.linspace(-oh * 0.5 + d, oh * 0.5 + d - 1, oh).unsqueeze_(-1)
base_grid[..., 1] = y_grid
scaled_theta = theta.transpose(
(0, 2, 1)) / paddle.to_tensor([0.5 * w, 0.5 * h])
output_grid = base_grid.reshape((1, oh * ow, 3)).bmm(scaled_theta)
return output_grid.reshape((1, oh, ow, 2))
def _grid_transform(img, grid, mode, fill):
if img.shape[0] > 1:
grid = grid.expand(img.shape[0], grid.shape[1], grid.shape[2],
grid.shape[3])
if fill is not None:
dummy = paddle.ones(
(img.shape[0], 1, img.shape[2], img.shape[3]), dtype=img.dtype)
img = paddle.concat((img, dummy), axis=1)
img = F.grid_sample(
img, grid, mode=mode, padding_mode="zeros", align_corners=False)
# Fill with required color
if fill is not None:
mask = img[:, -1:, :, :] # n 1 h w
img = img[:, :-1, :, :] # n c h w
mask = mask.expand_as(img)
len_fill = len(fill) if isinstance(fill, (tuple, list)) else 1
fill_img = paddle.to_tensor(fill).reshape(
(1, len_fill, 1, 1)).expand_as(img)
if mode == 'nearest':
mask = paddle.cast(mask < 0.5, img.dtype)
img = img * (1. - mask) + mask * fill_img
else: # 'bilinear'
img = img * mask + (1.0 - mask) * fill_img
return img
def rotate(img,
angle,
interpolation='nearest',
expand=False,
center=None,
fill=None,
data_format='CHW'):
"""Rotates the image by angle.
Args:
img (paddle.Tensor): Image to be rotated.
angle (float or int): In degrees degrees counter clockwise order.
interpolation (str, optional): Interpolation method. If omitted, or if the
image has only one channel, it is set NEAREST . when use pil backend,
support method are as following:
- "nearest"
- "bilinear"
- "bicubic"
expand (bool, optional): Optional expansion flag.
If true, expands the output image to make it large enough to hold the entire rotated image.
If false or omitted, make the output image the same size as the input image.
Note that the expand flag assumes rotation around the center and no translation.
center (2-tuple, optional): Optional center of rotation.
Origin is the upper left corner.
Default is the center of the image.
fill (3-tuple or int): RGB pixel fill value for area outside the rotated image.
If int, it is used for all channels respectively.
Returns:
paddle.Tensor: Rotated image.
"""
angle = -angle % 360
img = img.unsqueeze(0)
# n, c, h, w = img.shape
w, h = _get_image_size(img, data_format=data_format)
img = img if data_format.lower() == 'chw' else img.transpose((0, 3, 1, 2))
post_trans = [0, 0]
if center is None:
rotn_center = [0, 0]
else:
rotn_center = [(p - s * 0.5) for p, s in zip(center, [w, h])]
angle = math.radians(angle)
matrix = [
math.cos(angle),
math.sin(angle),
0.0,
-math.sin(angle),
math.cos(angle),
0.0,
]
matrix[2] += matrix[0] * (-rotn_center[0] - post_trans[0]) + matrix[1] * (
-rotn_center[1] - post_trans[1])
matrix[5] += matrix[3] * (-rotn_center[0] - post_trans[0]) + matrix[4] * (
-rotn_center[1] - post_trans[1])
matrix[2] += rotn_center[0]
matrix[5] += rotn_center[1]
matrix = paddle.to_tensor(matrix, place=img.place)
matrix = matrix.reshape((1, 2, 3))
if expand:
# calculate output size
corners = paddle.to_tensor(
[[-0.5 * w, -0.5 * h, 1.0], [-0.5 * w, 0.5 * h, 1.0],
[0.5 * w, 0.5 * h, 1.0], [0.5 * w, -0.5 * h, 1.0]],
place=matrix.place).astype(matrix.dtype)
_pos = corners.reshape(
(1, -1, 3)).bmm(matrix.transpose((0, 2, 1))).reshape((1, -1, 2))
_min = _pos.min(axis=-2).floor()
_max = _pos.max(axis=-2).ceil()
npos = _max - _min
nw = npos[0][0]
nh = npos[0][1]
ow, oh = int(nw.numpy()[0]), int(nh.numpy()[0])
else:
ow, oh = w, h
grid = _affine_grid(matrix, w, h, ow, oh)
out = _grid_transform(img, grid, mode=interpolation, fill=fill)
out = out if data_format.lower() == 'chw' else out.transpose((0, 2, 3, 1))
return out.squeeze(0)
def vflip(img, data_format='CHW'):
"""Vertically flips the given paddle tensor.
Args:
img (paddle.Tensor): Image to be flipped.
data_format (str, optional): Data format of img, should be 'HWC' or
'CHW'. Default: 'CHW'.
Returns:
paddle.Tensor: Vertically flipped image.
"""
_assert_image_tensor(img, data_format)
h_axis = _get_image_h_axis(data_format)
return img.flip(axis=[h_axis])
def hflip(img, data_format='CHW'):
"""Horizontally flips the given paddle.Tensor Image.
Args:
img (paddle.Tensor): Image to be flipped.
data_format (str, optional): Data format of img, should be 'HWC' or
'CHW'. Default: 'CHW'.
Returns:
paddle.Tensor: Horizontall flipped image.
"""
_assert_image_tensor(img, data_format)
w_axis = _get_image_w_axis(data_format)
return img.flip(axis=[w_axis])
def crop(img, top, left, height, width, data_format='CHW'):
"""Crops the given paddle.Tensor Image.
Args:
img (paddle.Tensor): Image to be cropped. (0,0) denotes the top left
corner of the image.
top (int): Vertical component of the top left corner of the crop box.
left (int): Horizontal component of the top left corner of the crop box.
height (int): Height of the crop box.
width (int): Width of the crop box.
data_format (str, optional): Data format of img, should be 'HWC' or
'CHW'. Default: 'CHW'.
Returns:
paddle.Tensor: Cropped image.
"""
_assert_image_tensor(img, data_format)
if _is_channel_first(data_format):
return img[:, top:top + height, left:left + width]
else:
return img[top:top + height, left:left + width, :]
def center_crop(img, output_size, data_format='CHW'):
"""Crops the given paddle.Tensor Image and resize it to desired size.
Args:
img (paddle.Tensor): Image to be cropped. (0,0) denotes the top left corner of the image.
output_size (sequence or int): (height, width) of the crop box. If int,
it is used for both directions
data_format (str, optional): Data format of img, should be 'HWC' or
'CHW'. Default: 'CHW'.
Returns:
paddle.Tensor: Cropped image.
"""
_assert_image_tensor(img, data_format)
if isinstance(output_size, numbers.Number):
output_size = (int(output_size), int(output_size))
image_width, image_height = _get_image_size(img, data_format)
crop_height, crop_width = output_size
crop_top = int(round((image_height - crop_height) / 2.))
crop_left = int(round((image_width - crop_width) / 2.))
return crop(
img,
crop_top,
crop_left,
crop_height,
crop_width,
data_format=data_format)
def pad(img, padding, fill=0, padding_mode='constant', data_format='CHW'):
"""
Pads the given paddle.Tensor on all sides with specified padding mode and fill value.
Args:
img (paddle.Tensor): Image to be padded.
padding (int|list|tuple): Padding on each border. If a single int is provided this
is used to pad all borders. If tuple of length 2 is provided this is the padding
on left/right and top/bottom respectively. If a tuple of length 4 is provided
this is the padding for the left, top, right and bottom borders
respectively.
fill (float, optional): Pixel fill value for constant fill. If a tuple of
length 3, it is used to fill R, G, B channels respectively.
This value is only used when the padding_mode is constant. Default: 0.
padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default: 'constant'.
- constant: pads with a constant value, this value is specified with fill
- edge: pads with the last value on the edge of the image
- reflect: pads with reflection of image (without repeating the last value on the edge)
padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode
will result in [3, 2, 1, 2, 3, 4, 3, 2]
- symmetric: pads with reflection of image (repeating the last value on the edge)
padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode
will result in [2, 1, 1, 2, 3, 4, 4, 3]
Returns:
paddle.Tensor: Padded image.
"""
_assert_image_tensor(img, data_format)
if not isinstance(padding, (numbers.Number, list, tuple)):
raise TypeError('Got inappropriate padding arg')
if not isinstance(fill, (numbers.Number, str, list, tuple)):
raise TypeError('Got inappropriate fill arg')
if not isinstance(padding_mode, str):
raise TypeError('Got inappropriate padding_mode arg')
if isinstance(padding, (list, tuple)) and len(padding) not in [2, 4]:
raise ValueError(
"Padding must be an int or a 2, or 4 element tuple, not a " +
"{} element tuple".format(len(padding)))
assert padding_mode in ['constant', 'edge', 'reflect', 'symmetric'], \
'Padding mode should be either constant, edge, reflect or symmetric'
if isinstance(padding, int):
pad_left = pad_right = pad_top = pad_bottom = padding
elif len(padding) == 2:
pad_left = pad_right = padding[0]
pad_top = pad_bottom = padding[1]
else:
pad_left = padding[0]
pad_top = padding[1]
pad_right = padding[2]
pad_bottom = padding[3]
padding = [pad_left, pad_right, pad_top, pad_bottom]
if padding_mode == 'edge':
padding_mode = 'replicate'
elif padding_mode == 'symmetric':
raise ValueError('Do not support symmetric mdoe')
img = img.unsqueeze(0)
# 'constant', 'reflect', 'replicate', 'circular'
img = F.pad(img,
pad=padding,
mode=padding_mode,
value=float(fill),
data_format='N' + data_format)
return img.squeeze(0)
def resize(img, size, interpolation='bilinear', data_format='CHW'):
"""
Resizes the image to given size
Args:
input (paddle.Tensor): Image to be resized.
size (int|list|tuple): Target size of input data, with (height, width) shape.
interpolation (int|str, optional): Interpolation method. when use paddle backend,
support method are as following:
- "nearest"
- "bilinear"
- "bicubic"
- "trilinear"
- "area"
- "linear"
data_format (str, optional): paddle.Tensor format
- 'CHW'
- 'HWC'
Returns:
paddle.Tensor: Resized image.
"""
_assert_image_tensor(img, data_format)
if not (isinstance(size, int) or
(isinstance(size, (tuple, list)) and len(size) == 2)):
raise TypeError('Got inappropriate size arg: {}'.format(size))
if isinstance(size, int):
w, h = _get_image_size(img, data_format)
if (w <= h and w == size) or (h <= w and h == size):
return img
if w < h:
ow = size
oh = int(size * h / w)
else:
oh = size
ow = int(size * w / h)
else:
oh, ow = size
img = img.unsqueeze(0)
img = F.interpolate(
img,
size=(oh, ow),
mode=interpolation.lower(),
data_format='N' + data_format.upper())
return img.squeeze(0)
...@@ -49,6 +49,8 @@ def _get_image_size(img): ...@@ -49,6 +49,8 @@ def _get_image_size(img):
return img.size return img.size
elif F._is_numpy_image(img): elif F._is_numpy_image(img):
return img.shape[:2][::-1] return img.shape[:2][::-1]
elif F._is_tensor_image(img):
return img.shape[1:][::-1] # chw
else: else:
raise TypeError("Unexpected type {}".format(type(img))) raise TypeError("Unexpected type {}".format(type(img)))
...@@ -690,6 +692,9 @@ class Transpose(BaseTransform): ...@@ -690,6 +692,9 @@ class Transpose(BaseTransform):
self.order = order self.order = order
def _apply_image(self, img): def _apply_image(self, img):
if F._is_tensor_image(img):
return img.transpose(self.order)
if F._is_pil_image(img): if F._is_pil_image(img):
img = np.asarray(img) img = np.asarray(img)
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册