|
|
| |
|
|
| import numpy as np |
| import math |
| import cv2 |
| |
| |
|
|
| |
| |
|
|
| class State: |
| def __init__(self, autoload=True, default=None): |
| self.autoload = autoload |
| self.default = default |
|
|
| |
| class RandomCropData(): |
| size = (512, 512) |
| max_tries = 50 |
| min_crop_side_ratio = 0.1 |
| require_original_image = False |
|
|
| def __init__(self, **kwargs): |
| pass |
|
|
| def process(self, data): |
| img = data['image'] |
| ori_img = img |
| ori_lines = data['polys'] |
|
|
| all_care_polys = [line['points'] |
| for line in data['polys'] if not line['ignore']] |
| crop_x, crop_y, crop_w, crop_h = self.crop_area(img, all_care_polys) |
| scale_w = self.size[0] / crop_w |
| scale_h = self.size[1] / crop_h |
| scale = min(scale_w, scale_h) |
| h = int(crop_h * scale) |
| w = int(crop_w * scale) |
| padimg = np.zeros( |
| (self.size[1], self.size[0], img.shape[2]), img.dtype) |
| padimg[:h, :w] = cv2.resize( |
| img[crop_y:crop_y + crop_h, crop_x:crop_x + crop_w], (w, h)) |
| img = padimg |
|
|
| lines = [] |
| for line in data['polys']: |
| poly = ((np.array(line['points']) - |
| (crop_x, crop_y)) * scale).tolist() |
| if not self.is_poly_outside_rect(poly, 0, 0, w, h): |
| lines.append({**line, 'points': poly}) |
| data['polys'] = lines |
|
|
| if self.require_original_image: |
| data['image'] = ori_img |
| else: |
| data['image'] = img |
| data['lines'] = ori_lines |
| data['scale_w'] = scale |
| data['scale_h'] = scale |
|
|
| return data |
|
|
| def is_poly_in_rect(self, poly, x, y, w, h): |
| poly = np.array(poly) |
| if poly[:, 0].min() < x or poly[:, 0].max() > x + w: |
| return False |
| if poly[:, 1].min() < y or poly[:, 1].max() > y + h: |
| return False |
| return True |
|
|
| def is_poly_outside_rect(self, poly, x, y, w, h): |
| poly = np.array(poly) |
| if poly[:, 0].max() < x or poly[:, 0].min() > x + w: |
| return True |
| if poly[:, 1].max() < y or poly[:, 1].min() > y + h: |
| return True |
| return False |
|
|
| def split_regions(self, axis): |
| regions = [] |
| min_axis = 0 |
| for i in range(1, axis.shape[0]): |
| if axis[i] != axis[i-1] + 1: |
| region = axis[min_axis:i] |
| min_axis = i |
| regions.append(region) |
| return regions |
|
|
| def random_select(self, axis, max_size): |
| xx = np.random.choice(axis, size=2) |
| xmin = np.min(xx) |
| xmax = np.max(xx) |
| xmin = np.clip(xmin, 0, max_size - 1) |
| xmax = np.clip(xmax, 0, max_size - 1) |
| return xmin, xmax |
|
|
| def region_wise_random_select(self, regions, max_size): |
| selected_index = list(np.random.choice(len(regions), 2)) |
| selected_values = [] |
| for index in selected_index: |
| axis = regions[index] |
| xx = int(np.random.choice(axis, size=1)) |
| selected_values.append(xx) |
| xmin = min(selected_values) |
| xmax = max(selected_values) |
| return xmin, xmax |
|
|
| def crop_area(self, img, polys): |
| h, w, _ = img.shape |
| h_array = np.zeros(h, dtype=np.int32) |
| w_array = np.zeros(w, dtype=np.int32) |
| for points in polys: |
| points = np.round(points, decimals=0).astype(np.int32) |
| minx = np.min(points[:, 0]) |
| maxx = np.max(points[:, 0]) |
| w_array[minx:maxx] = 1 |
| miny = np.min(points[:, 1]) |
| maxy = np.max(points[:, 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 0, 0, w, h |
|
|
| h_regions = self.split_regions(h_axis) |
| w_regions = self.split_regions(w_axis) |
|
|
| for i in range(self.max_tries): |
| if len(w_regions) > 1: |
| xmin, xmax = self.region_wise_random_select(w_regions, w) |
| else: |
| xmin, xmax = self.random_select(w_axis, w) |
| if len(h_regions) > 1: |
| ymin, ymax = self.region_wise_random_select(h_regions, h) |
| else: |
| ymin, ymax = self.random_select(h_axis, h) |
|
|
| if xmax - xmin < self.min_crop_side_ratio * w or ymax - ymin < self.min_crop_side_ratio * h: |
| |
| continue |
| num_poly_in_rect = 0 |
| for poly in polys: |
| if not self.is_poly_outside_rect(poly, xmin, ymin, xmax - xmin, ymax - ymin): |
| num_poly_in_rect += 1 |
| break |
|
|
| if num_poly_in_rect > 0: |
| return xmin, ymin, xmax - xmin, ymax - ymin |
|
|
| return 0, 0, w, h |
|
|
|
|
| if __name__ == "__main__": |
| |
| im = './datasets/icdar2015/train_images/img_1.jpg' |
| gt = './datasets/icdar2015/train_gts/gt_img_1.txt' |
| |
| items = [] |
| reader = open(gt, 'r').readlines() |
| for line in reader: |
| item = {} |
| parts = line.strip().split(',') |
| label = parts[-1] |
| if 'TD' in gt and label == '1': |
| label = '###' |
| line = [i.strip('\ufeff').strip('\xef\xbb\xbf') for i in parts] |
| if 'icdar' in gt: |
| poly = np.array(list(map(float, line[:8]))).reshape( |
| (-1, 2)).tolist() |
| else: |
| num_points = math.floor((len(line) - 1) / 2) * 2 |
| poly = np.array(list(map(float, line[:num_points]))).reshape( |
| (-1, 2)).tolist() |
| item['points'] = poly |
| item['text'] = label |
| item['ignore'] = True if label == '###' else False |
| items.append( item ) |
|
|
| img = cv2.imdecode(np.fromfile(im, dtype=np.uint8), -1) |
| img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) |
| img_shape = img.shape |
|
|
| data = dict( |
| image = img, |
| polys = items, |
| ) |
|
|
| crop = RandomCropData() |
| crop.process(data) |
|
|
