mirror of
https://github.com/FoundationVision/GLEE.git
synced 2025-06-03 14:51:17 +08:00
269 lines
11 KiB
Python
269 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright (c) Facebook, Inc. and its affiliates.
|
|
|
|
import logging
|
|
import numpy as np
|
|
import unittest
|
|
from unittest import mock
|
|
import torch
|
|
from PIL import Image, ImageOps
|
|
from torch.nn import functional as F
|
|
|
|
from detectron2.config import get_cfg
|
|
from detectron2.data import detection_utils
|
|
from detectron2.data import transforms as T
|
|
from detectron2.utils.logger import setup_logger
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def polygon_allclose(poly1, poly2):
|
|
"""
|
|
Test whether two polygons are the same.
|
|
Both arguments are nx2 numpy arrays.
|
|
"""
|
|
# ABCD and CDAB are the same polygon. So it's important to check after rolling
|
|
for k in range(len(poly1)):
|
|
rolled_poly1 = np.roll(poly1, k, axis=0)
|
|
if np.allclose(rolled_poly1, poly2):
|
|
return True
|
|
return False
|
|
|
|
|
|
class TestTransforms(unittest.TestCase):
|
|
def setUp(self):
|
|
setup_logger()
|
|
|
|
def test_apply_rotated_boxes(self):
|
|
np.random.seed(125)
|
|
cfg = get_cfg()
|
|
is_train = True
|
|
augs = detection_utils.build_augmentation(cfg, is_train)
|
|
image = np.random.rand(200, 300)
|
|
image, transforms = T.apply_augmentations(augs, image)
|
|
image_shape = image.shape[:2] # h, w
|
|
assert image_shape == (800, 1200)
|
|
annotation = {"bbox": [179, 97, 62, 40, -56]}
|
|
|
|
boxes = np.array([annotation["bbox"]], dtype=np.float64) # boxes.shape = (1, 5)
|
|
transformed_bbox = transforms.apply_rotated_box(boxes)[0]
|
|
|
|
expected_bbox = np.array([484, 388, 248, 160, 56], dtype=np.float64)
|
|
err_msg = "transformed_bbox = {}, expected {}".format(transformed_bbox, expected_bbox)
|
|
assert np.allclose(transformed_bbox, expected_bbox), err_msg
|
|
|
|
def test_resize_and_crop(self):
|
|
np.random.seed(125)
|
|
min_scale = 0.2
|
|
max_scale = 2.0
|
|
target_height = 1100
|
|
target_width = 1000
|
|
resize_aug = T.ResizeScale(min_scale, max_scale, target_height, target_width)
|
|
fixed_size_crop_aug = T.FixedSizeCrop((target_height, target_width))
|
|
hflip_aug = T.RandomFlip()
|
|
augs = [resize_aug, fixed_size_crop_aug, hflip_aug]
|
|
original_image = np.random.rand(900, 800)
|
|
image, transforms = T.apply_augmentations(augs, original_image)
|
|
image_shape = image.shape[:2] # h, w
|
|
self.assertEqual((1100, 1000), image_shape)
|
|
|
|
boxes = np.array(
|
|
[[91, 46, 144, 111], [523, 251, 614, 295]],
|
|
dtype=np.float64,
|
|
)
|
|
transformed_bboxs = transforms.apply_box(boxes)
|
|
expected_bboxs = np.array(
|
|
[
|
|
[895.42, 33.42666667, 933.91125, 80.66],
|
|
[554.0825, 182.39333333, 620.17125, 214.36666667],
|
|
],
|
|
dtype=np.float64,
|
|
)
|
|
err_msg = "transformed_bbox = {}, expected {}".format(transformed_bboxs, expected_bboxs)
|
|
self.assertTrue(np.allclose(transformed_bboxs, expected_bboxs), err_msg)
|
|
|
|
polygon = np.array([[91, 46], [144, 46], [144, 111], [91, 111]])
|
|
transformed_polygons = transforms.apply_polygons([polygon])
|
|
expected_polygon = np.array([[934.0, 33.0], [934.0, 80.0], [896.0, 80.0], [896.0, 33.0]])
|
|
self.assertEqual(1, len(transformed_polygons))
|
|
err_msg = "transformed_polygon = {}, expected {}".format(
|
|
transformed_polygons[0], expected_polygon
|
|
)
|
|
self.assertTrue(polygon_allclose(transformed_polygons[0], expected_polygon), err_msg)
|
|
|
|
def test_apply_rotated_boxes_unequal_scaling_factor(self):
|
|
np.random.seed(125)
|
|
h, w = 400, 200
|
|
newh, neww = 800, 800
|
|
image = np.random.rand(h, w)
|
|
augs = []
|
|
augs.append(T.Resize(shape=(newh, neww)))
|
|
image, transforms = T.apply_augmentations(augs, image)
|
|
image_shape = image.shape[:2] # h, w
|
|
assert image_shape == (newh, neww)
|
|
|
|
boxes = np.array(
|
|
[
|
|
[150, 100, 40, 20, 0],
|
|
[150, 100, 40, 20, 30],
|
|
[150, 100, 40, 20, 90],
|
|
[150, 100, 40, 20, -90],
|
|
],
|
|
dtype=np.float64,
|
|
)
|
|
transformed_boxes = transforms.apply_rotated_box(boxes)
|
|
|
|
expected_bboxes = np.array(
|
|
[
|
|
[600, 200, 160, 40, 0],
|
|
[600, 200, 144.22205102, 52.91502622, 49.10660535],
|
|
[600, 200, 80, 80, 90],
|
|
[600, 200, 80, 80, -90],
|
|
],
|
|
dtype=np.float64,
|
|
)
|
|
err_msg = "transformed_boxes = {}, expected {}".format(transformed_boxes, expected_bboxes)
|
|
assert np.allclose(transformed_boxes, expected_bboxes), err_msg
|
|
|
|
def test_print_augmentation(self):
|
|
t = T.RandomCrop("relative", (100, 100))
|
|
self.assertEqual(str(t), "RandomCrop(crop_type='relative', crop_size=(100, 100))")
|
|
|
|
t0 = T.RandomFlip(prob=0.5)
|
|
self.assertEqual(str(t0), "RandomFlip(prob=0.5)")
|
|
|
|
t1 = T.RandomFlip()
|
|
self.assertEqual(str(t1), "RandomFlip()")
|
|
|
|
t = T.AugmentationList([t0, t1])
|
|
self.assertEqual(str(t), f"AugmentationList[{t0}, {t1}]")
|
|
|
|
def test_random_apply_prob_out_of_range_check(self):
|
|
test_probabilities = {0.0: True, 0.5: True, 1.0: True, -0.01: False, 1.01: False}
|
|
|
|
for given_probability, is_valid in test_probabilities.items():
|
|
if not is_valid:
|
|
self.assertRaises(AssertionError, T.RandomApply, None, prob=given_probability)
|
|
else:
|
|
T.RandomApply(T.NoOpTransform(), prob=given_probability)
|
|
|
|
def test_random_apply_wrapping_aug_probability_occured_evaluation(self):
|
|
transform_mock = mock.MagicMock(name="MockTransform", spec=T.Augmentation)
|
|
image_mock = mock.MagicMock(name="MockImage")
|
|
random_apply = T.RandomApply(transform_mock, prob=0.001)
|
|
|
|
with mock.patch.object(random_apply, "_rand_range", return_value=0.0001):
|
|
transform = random_apply.get_transform(image_mock)
|
|
transform_mock.get_transform.assert_called_once_with(image_mock)
|
|
self.assertIsNot(transform, transform_mock)
|
|
|
|
def test_random_apply_wrapping_std_transform_probability_occured_evaluation(self):
|
|
transform_mock = mock.MagicMock(name="MockTransform", spec=T.Transform)
|
|
image_mock = mock.MagicMock(name="MockImage")
|
|
random_apply = T.RandomApply(transform_mock, prob=0.001)
|
|
|
|
with mock.patch.object(random_apply, "_rand_range", return_value=0.0001):
|
|
transform = random_apply.get_transform(image_mock)
|
|
self.assertIs(transform, transform_mock)
|
|
|
|
def test_random_apply_probability_not_occured_evaluation(self):
|
|
transform_mock = mock.MagicMock(name="MockTransform", spec=T.Augmentation)
|
|
image_mock = mock.MagicMock(name="MockImage")
|
|
random_apply = T.RandomApply(transform_mock, prob=0.001)
|
|
|
|
with mock.patch.object(random_apply, "_rand_range", return_value=0.9):
|
|
transform = random_apply.get_transform(image_mock)
|
|
transform_mock.get_transform.assert_not_called()
|
|
self.assertIsInstance(transform, T.NoOpTransform)
|
|
|
|
def test_augmentation_input_args(self):
|
|
input_shape = (100, 100)
|
|
output_shape = (50, 50)
|
|
|
|
# define two augmentations with different args
|
|
class TG1(T.Augmentation):
|
|
def get_transform(self, image, sem_seg):
|
|
return T.ResizeTransform(
|
|
input_shape[0], input_shape[1], output_shape[0], output_shape[1]
|
|
)
|
|
|
|
class TG2(T.Augmentation):
|
|
def get_transform(self, image):
|
|
assert image.shape[:2] == output_shape # check that TG1 is applied
|
|
return T.HFlipTransform(output_shape[1])
|
|
|
|
image = np.random.rand(*input_shape).astype("float32")
|
|
sem_seg = (np.random.rand(*input_shape) < 0.5).astype("uint8")
|
|
inputs = T.AugInput(image, sem_seg=sem_seg) # provide two args
|
|
tfms = inputs.apply_augmentations([TG1(), TG2()])
|
|
self.assertIsInstance(tfms[0], T.ResizeTransform)
|
|
self.assertIsInstance(tfms[1], T.HFlipTransform)
|
|
self.assertTrue(inputs.image.shape[:2] == output_shape)
|
|
self.assertTrue(inputs.sem_seg.shape[:2] == output_shape)
|
|
|
|
class TG3(T.Augmentation):
|
|
def get_transform(self, image, nonexist):
|
|
pass
|
|
|
|
with self.assertRaises(AttributeError):
|
|
inputs.apply_augmentations([TG3()])
|
|
|
|
def test_augmentation_list(self):
|
|
input_shape = (100, 100)
|
|
image = np.random.rand(*input_shape).astype("float32")
|
|
sem_seg = (np.random.rand(*input_shape) < 0.5).astype("uint8")
|
|
inputs = T.AugInput(image, sem_seg=sem_seg) # provide two args
|
|
|
|
augs = T.AugmentationList([T.RandomFlip(), T.Resize(20)])
|
|
_ = T.AugmentationList([augs, T.Resize(30)])(inputs)
|
|
# 3 in latest fvcore (flattened transformlist), 2 in older
|
|
# self.assertEqual(len(tfms), 3)
|
|
|
|
def test_color_transforms(self):
|
|
rand_img = np.random.random((100, 100, 3)) * 255
|
|
rand_img = rand_img.astype("uint8")
|
|
|
|
# Test no-op
|
|
noop_transform = T.ColorTransform(lambda img: img)
|
|
self.assertTrue(np.array_equal(rand_img, noop_transform.apply_image(rand_img)))
|
|
|
|
# Test a ImageOps operation
|
|
magnitude = np.random.randint(0, 256)
|
|
solarize_transform = T.PILColorTransform(lambda img: ImageOps.solarize(img, magnitude))
|
|
expected_img = ImageOps.solarize(Image.fromarray(rand_img), magnitude)
|
|
self.assertTrue(np.array_equal(expected_img, solarize_transform.apply_image(rand_img)))
|
|
|
|
def test_resize_transform(self):
|
|
input_shapes = [(100, 100), (100, 100, 1), (100, 100, 3)]
|
|
output_shapes = [(200, 200), (200, 200, 1), (200, 200, 3)]
|
|
for in_shape, out_shape in zip(input_shapes, output_shapes):
|
|
in_img = np.random.randint(0, 255, size=in_shape, dtype=np.uint8)
|
|
tfm = T.ResizeTransform(in_shape[0], in_shape[1], out_shape[0], out_shape[1])
|
|
out_img = tfm.apply_image(in_img)
|
|
self.assertEqual(out_img.shape, out_shape)
|
|
|
|
def test_resize_shorted_edge_scriptable(self):
|
|
def f(image):
|
|
newh, neww = T.ResizeShortestEdge.get_output_shape(
|
|
image.shape[-2], image.shape[-1], 80, 133
|
|
)
|
|
return F.interpolate(image.unsqueeze(0), size=(newh, neww))
|
|
|
|
input = torch.randn(3, 10, 10)
|
|
script_f = torch.jit.script(f)
|
|
self.assertTrue(torch.allclose(f(input), script_f(input)))
|
|
|
|
# generalize to new shapes
|
|
input = torch.randn(3, 8, 100)
|
|
self.assertTrue(torch.allclose(f(input), script_f(input)))
|
|
|
|
def test_extent_transform(self):
|
|
input_shapes = [(100, 100), (100, 100, 1), (100, 100, 3)]
|
|
src_rect = (20, 20, 80, 80)
|
|
output_shapes = [(200, 200), (200, 200, 1), (200, 200, 3)]
|
|
for in_shape, out_shape in zip(input_shapes, output_shapes):
|
|
in_img = np.random.randint(0, 255, size=in_shape, dtype=np.uint8)
|
|
tfm = T.ExtentTransform(src_rect, out_shape[:2])
|
|
out_img = tfm.apply_image(in_img)
|
|
self.assertTrue(out_img.shape == out_shape)
|