|
|
import random |
|
|
import cv2 |
|
|
import numpy as np |
|
|
from shapely.geometry import Polygon |
|
|
from shapely import affinity |
|
|
|
|
|
from concern.config import Configurable, State |
|
|
|
|
|
|
|
|
def regular_resize(image, boxes, tags, crop_size): |
|
|
h, w, c = image.shape |
|
|
if h < w: |
|
|
scale_ratio = crop_size * 1.0 / w |
|
|
new_h = int(round(crop_size * h * 1.0 / w)) |
|
|
if new_h > crop_size: |
|
|
new_h = crop_size |
|
|
image = cv2.resize(image, (crop_size, new_h)) |
|
|
new_img = np.zeros((crop_size, crop_size, 3)) |
|
|
new_img[:new_h, :, :] = image |
|
|
boxes *= scale_ratio |
|
|
else: |
|
|
scale_ratio = crop_size * 1.0 / h |
|
|
new_w = int(round(crop_size * w * 1.0 / h)) |
|
|
if new_w > crop_size: |
|
|
new_w = crop_size |
|
|
image = cv2.resize(image, (new_w, crop_size)) |
|
|
new_img = np.zeros((crop_size, crop_size, 3)) |
|
|
new_img[:, :new_w, :] = image |
|
|
boxes *= scale_ratio |
|
|
return new_img, boxes, tags |
|
|
|
|
|
|
|
|
def random_crop(image, boxes, tags, crop_size, max_tries, w_axis, h_axis, min_crop_side_ratio): |
|
|
h, w, c = image.shape |
|
|
selected_boxes = [] |
|
|
for i in range(max_tries): |
|
|
xx = np.random.choice(w_axis, size=2) |
|
|
xmin = np.min(xx) |
|
|
xmax = np.max(xx) |
|
|
xmin = np.clip(xmin, 0, w-1) |
|
|
xmax = np.clip(xmax, 0, w-1) |
|
|
yy = np.random.choice(h_axis, size=2) |
|
|
ymin = np.min(yy) |
|
|
ymax = np.max(yy) |
|
|
ymin = np.clip(ymin, 0, h-1) |
|
|
ymax = np.clip(ymax, 0, h-1) |
|
|
if xmax - xmin < min_crop_side_ratio*w or ymax - ymin < min_crop_side_ratio*h: |
|
|
|
|
|
continue |
|
|
if boxes.shape[0] != 0: |
|
|
box_axis_in_area = (boxes[:, :, 0] >= xmin) & (boxes[:, :, 0] <= xmax) \ |
|
|
& (boxes[:, :, 1] >= ymin) & (boxes[:, :, 1] <= ymax) |
|
|
selected_boxes = np.where(np.sum(box_axis_in_area, axis=1) == 4)[0] |
|
|
if len(selected_boxes) > 0: |
|
|
if (tags[selected_boxes] == False).astype(np.float).sum() > 0: |
|
|
break |
|
|
else: |
|
|
selected_boxes = [] |
|
|
break |
|
|
if i == max_tries - 1: |
|
|
return regular_resize(image, boxes, tags, crop_size) |
|
|
|
|
|
image = image[ymin:ymax+1, xmin:xmax+1, :] |
|
|
boxes = boxes[selected_boxes] |
|
|
tags = tags[selected_boxes] |
|
|
boxes[:, :, 0] -= xmin |
|
|
boxes[:, :, 1] -= ymin |
|
|
return regular_resize(image, boxes, tags, crop_size) |
|
|
|
|
|
|
|
|
def regular_crop(image, boxes, tags, crop_size, max_tries, w_array, h_array, w_axis, h_axis, min_crop_side_ratio): |
|
|
h, w, c = image.shape |
|
|
mask_w = np.arange(w - crop_size) |
|
|
mask_h = np.arange(h - crop_size) |
|
|
keep_w = np.where(np.logical_and( |
|
|
w_array[mask_w] == 0, w_array[mask_w + crop_size - 1] == 0))[0] |
|
|
keep_h = np.where(np.logical_and( |
|
|
h_array[mask_h] == 0, h_array[mask_h + crop_size - 1] == 0))[0] |
|
|
|
|
|
if keep_w.size > 0 and keep_h.size > 0: |
|
|
for i in range(max_tries): |
|
|
xmin = np.random.choice(keep_w, size=1)[0] |
|
|
xmax = xmin + crop_size |
|
|
ymin = np.random.choice(keep_h, size=1)[0] |
|
|
ymax = ymin + crop_size |
|
|
if boxes.shape[0] != 0: |
|
|
box_axis_in_area = (boxes[:, :, 0] >= xmin) & (boxes[:, :, 0] <= xmax) \ |
|
|
& (boxes[:, :, 1] >= ymin) & (boxes[:, :, 1] <= ymax) |
|
|
selected_boxes = np.where( |
|
|
np.sum(box_axis_in_area, axis=1) == 4)[0] |
|
|
if len(selected_boxes) > 0: |
|
|
if (tags[selected_boxes] == False).astype(np.float).sum() > 0: |
|
|
break |
|
|
else: |
|
|
selected_boxes = [] |
|
|
break |
|
|
if i == max_tries-1: |
|
|
return random_crop(image, boxes, tags, crop_size, max_tries, w_axis, h_axis, min_crop_side_ratio) |
|
|
image = image[ymin:ymax, xmin:xmax, :] |
|
|
boxes = boxes[selected_boxes] |
|
|
tags = tags[selected_boxes] |
|
|
boxes[:, :, 0] -= xmin |
|
|
boxes[:, :, 1] -= ymin |
|
|
return image, boxes, tags |
|
|
else: |
|
|
return random_crop(image, boxes, tags, crop_size, max_tries, w_axis, h_axis, min_crop_side_ratio) |
|
|
|
|
|
|
|
|
class RandomCrop(object): |
|
|
def __init__(self, crop_size=640, max_tries=50, min_crop_side_ratio=0.1): |
|
|
self.crop_size = crop_size |
|
|
self.max_tries = max_tries |
|
|
self.min_crop_side_ratio = min_crop_side_ratio |
|
|
|
|
|
def __call__(self, image, boxes, tags): |
|
|
h, w, _ = image.shape |
|
|
h_array = np.zeros((h), dtype=np.int32) |
|
|
w_array = np.zeros((w), dtype=np.int32) |
|
|
|
|
|
for box in boxes: |
|
|
box = np.round(box, decimals=0).astype(np.int32) |
|
|
minx = np.min(box[:, 0]) |
|
|
maxx = np.max(box[:, 0]) |
|
|
w_array[minx:maxx] = 1 |
|
|
miny = np.min(box[:, 1]) |
|
|
maxy = np.max(box[:, 1]) |
|
|
h_array[miny:maxy] = 1 |
|
|
|
|
|
h_axis = np.where(h_array == 0)[0] |
|
|
w_axis = np.where(w_array == 0)[0] |
|
|
if len(h_axis) == 0 or len(w_axis) == 0: |
|
|
|
|
|
return regular_resize(image, boxes, tags, self.crop_size) |
|
|
|
|
|
if h <= self.crop_size + 1 or w <= self.crop_size + 1: |
|
|
return random_crop(image, boxes, tags, self.crop_size, self.max_tries, w_axis, h_axis, self.min_crop_side_ratio) |
|
|
else: |
|
|
return regular_crop(image, boxes, tags, self.crop_size, self.max_tries, w_array, h_array, w_axis, h_axis, self.min_crop_side_ratio) |
|
|
|
|
|
|
|
|
class RandomCropAug(Configurable): |
|
|
size = State(default=640) |
|
|
|
|
|
def __init__(self, size=640, *args, **kwargs): |
|
|
self.size = size or self.size |
|
|
self.augment = RandomCrop(size) |
|
|
|
|
|
def __call__(self, data): |
|
|
''' |
|
|
This augmenter is supposed to following the process of `MakeICDARData`, |
|
|
in which labels are mapped to this specific format: |
|
|
(image, polygons: (n, 4, 2), tags: [Boolean], ...) |
|
|
''' |
|
|
image, boxes, ignore_tags = data[:3] |
|
|
image, boxes, ignore_tags = self.augment(image, boxes, ignore_tags) |
|
|
return (image, boxes, ignore_tags, *data[3:]) |
|
|
|
