| import pickle |
|
|
| import cv2 |
| import skimage |
| import numpy as np |
| from shapely.geometry import Polygon |
|
|
| from concern.config import Configurable, State |
|
|
|
|
| def binary_search_smallest_width(poly): |
| if len(poly) < 3: |
| return 0 |
| poly = Polygon(poly) |
| low = 0 |
| high = 65536 |
| while high - low > 0.1: |
| mid = (high + low) / 2 |
| mid_poly = poly.buffer(-mid) |
| if mid_poly.geom_type == 'Polygon' and mid_poly.area > 0.1: |
| low = mid |
| else: |
| high = mid |
| height = (low + high) / 2 |
| if height < 0.1: |
| return 0 |
| else: |
| return height |
|
|
|
|
| def project_point_to_line(x, u, v, axis=0): |
| n = v - u |
| n = n / (np.linalg.norm(n, axis=axis, keepdims=True) + np.finfo(np.float32).eps) |
| p = u + n * np.sum((x - u) * n, axis=axis, keepdims=True) |
| return p |
|
|
|
|
| def project_point_to_segment(x, u, v, axis=0): |
| p = project_point_to_line(x, u, v, axis=axis) |
| outer = np.greater_equal(np.sum((u - p) * (v - p), axis=axis, keepdims=True), 0) |
| near_u = np.less_equal( |
| np.linalg.norm(u - p, axis=axis, keepdims=True), |
| np.linalg.norm(v - p, axis=axis, keepdims=True) |
| ) |
| o = np.where(outer, np.where(near_u, u, v), p) |
| return o |
|
|
|
|
| class MakeSimpleDetectionData(Configurable): |
| center_shrink = State(default=0.5) |
| background_weight = State(default=3.0) |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
|
|
| def get_mask(self, w, h, polys, ignores): |
| mask = np.ones((h, w), np.float32) |
|
|
| for poly, ignore in zip(polys, ignores): |
| if ignore: |
| cv2.fillPoly(mask, np.array([poly], np.int32), 0.0) |
|
|
| return mask |
|
|
| def get_line_height(self, poly): |
| return binary_search_smallest_width(poly) |
|
|
| def get_regions_coords(self, w, h, polys, heights, shrink): |
| label_map = np.zeros((h, w), np.int32) |
| for line_id, (poly, height) in enumerate(zip(polys, heights)): |
| if height > 0: |
| shrinked_poly = Polygon(poly).buffer(-height * shrink) |
| if shrinked_poly.geom_type == 'Polygon' and not shrinked_poly.is_empty: |
| shrinked_poly = np.array(list(shrinked_poly.exterior.coords), np.int32) |
| cv2.fillPoly(label_map, shrinked_poly[np.newaxis], line_id + 1) |
|
|
| regions = skimage.measure.regionprops(label_map) |
| regions_coords = [ |
| region.coords[:, ::-1] for region in regions |
| ] + [ |
| np.zeros((0, 2), 'int32') |
| ] * (len(polys) - len(regions)) |
|
|
| return regions_coords |
|
|
| def get_coords_poly_projection(self, coords, poly): |
| start_points = np.array(poly) |
| end_points = np.concatenate([poly[1:], poly[:1]], axis=0) |
| region_points = coords |
|
|
| projected_points = project_point_to_segment( |
| region_points[:, np.newaxis], |
| start_points[np.newaxis], |
| end_points[np.newaxis], |
| axis=2, |
| ) |
| projection_distances = np.linalg.norm(region_points[:, np.newaxis] - projected_points, axis=2) |
| best_projected_points = projected_points[np.arange(len(region_points)), np.argmin(projection_distances, axis=1)] |
| return best_projected_points |
|
|
| def get_coords_poly_distance(self, coords, poly): |
| projection = self.get_coords_poly_projection(coords, poly) |
| return np.linalg.norm(projection - coords, axis=1) |
|
|
| def get_normalized_weight(self, heatmap, mask): |
| pos = np.greater_equal(heatmap, 0.5) |
| neg = 1 - pos |
| pos = np.logical_and(pos, mask) |
| neg = np.logical_and(neg, mask) |
| npos = pos.sum() |
| nneg = neg.sum() |
| smooth = (npos + nneg + 1) * 0.05 |
| wpos = (nneg + smooth) / (npos + smooth) |
| weight = np.zeros_like(heatmap) |
| weight[neg] = self.background_weight |
| weight[pos] = wpos |
| return weight |
|
|
| def draw_maps(self, w, h, polys, ignores): |
| raise NotImplementedError() |
|
|
| def __call__(self, data, *args, **kwargs): |
| image, label, meta = data |
| lines = label['polys'] |
|
|
| h, w = image.shape[:2] |
|
|
| polys = [] |
| ignores = [] |
| for line in lines: |
| if len(line['points']) >= 4: |
| polys.append(line['points']) |
| ignores.append(line['ignore']) |
|
|
| maps = self.draw_maps(w, h, polys, ignores) |
|
|
| |
| image = image.transpose(2, 0, 1) |
|
|
| label = maps |
| return image, label, pickle.dumps(meta) |
|
|
|
|
| class MakeSimpleSegData(MakeSimpleDetectionData): |
| def draw_maps(self, w, h, polys, ignores): |
| heatmap = np.zeros((h, w), np.float32) |
|
|
| heights = [self.get_line_height(poly) for poly in polys] |
| regions_center_coords = self.get_regions_coords(w, h, polys, heights, self.center_shrink) |
| train_mask = self.get_mask(w, h, polys, ignores) |
| for region_center_coords in regions_center_coords: |
| x, y = region_center_coords[:, 0], region_center_coords[:, 1] |
| heatmap[y, x] = 1.0 |
| heatmap_weight = self.get_normalized_weight(heatmap, train_mask) |
|
|
| return { |
| 'heatmap': heatmap[np.newaxis], |
| 'heatmap_weight': heatmap_weight[np.newaxis], |
| } |
|
|
|
|
| class MakeSimpleEASTData(MakeSimpleDetectionData): |
| def draw_maps(self, w, h, polys, ignores): |
| heatmap = np.zeros((h, w), np.float32) |
| densebox = np.zeros((8, h, w), np.float32) |
| densebox_weight = np.zeros((h, w), np.float32) |
|
|
| heights = [self.get_line_height(poly) for poly in polys] |
| regions_center_coords = self.get_regions_coords(w, h, polys, heights, self.center_shrink) |
| train_mask = self.get_mask(w, h, polys, ignores) |
| for poly, region_center_coords in zip(polys, regions_center_coords): |
| x, y = region_center_coords[:, 0], region_center_coords[:, 1] |
| heatmap[y, x] = 1.0 |
| densebox_weight[y, x] = 1.0 |
|
|
| for i in range(0, 4): |
| densebox[i * 2, y, x] = float(poly[i][0]) - x |
| densebox[i * 2 + 1, y, x] = float(poly[i][1]) - y |
|
|
| heatmap_weight = self.get_normalized_weight(heatmap, train_mask) |
| densebox_weight = densebox_weight * train_mask |
|
|
| return { |
| 'heatmap': heatmap[np.newaxis], |
| 'heatmap_weight': heatmap_weight[np.newaxis], |
| 'densebox': densebox, |
| 'densebox_weight': densebox_weight[np.newaxis], |
| } |
|
|
|
|
| class MakeSimpleTextsnakeData(MakeSimpleDetectionData): |
| def draw_maps(self, w, h, polys, ignores): |
| heatmap = np.zeros((h, w), np.float32) |
| radius = np.zeros((h, w), np.float32) |
| radius_weight = np.zeros((h, w), np.float32) |
|
|
| heights = [self.get_line_height(poly) for poly in polys] |
| regions_center_coords = self.get_regions_coords(w, h, polys, heights, self.center_shrink) |
| train_mask = self.get_mask(w, h, polys, ignores) |
| for poly, region_center_coords in zip(polys, regions_center_coords): |
| x, y = region_center_coords[:, 0], region_center_coords[:, 1] |
| heatmap[y, x] = 1.0 |
|
|
| distance = self.get_coords_poly_distance(region_center_coords, poly) |
| radius[y, x] = distance |
| radius_weight[y, x] = 1.0 |
|
|
| heatmap_weight = self.get_normalized_weight(heatmap, train_mask) |
| radius_weight = radius_weight * train_mask |
|
|
| return { |
| 'heatmap': heatmap[np.newaxis], |
| 'heatmap_weight': heatmap_weight[np.newaxis], |
| 'radius': radius[np.newaxis], |
| 'radius_weight': radius_weight[np.newaxis], |
| } |
|
|
|
|
| class MakeSimpleMSRData(MakeSimpleDetectionData): |
| def draw_maps(self, w, h, polys, ignores): |
| heatmap = np.zeros((h, w), np.float32) |
| offset = np.zeros((2, h, w), np.float32) |
| offset_weight = np.zeros((h, w), np.float32) |
|
|
| heights = [self.get_line_height(poly) for poly in polys] |
| regions_center_coords = self.get_regions_coords(w, h, polys, heights, self.center_shrink) |
| train_mask = self.get_mask(w, h, polys, ignores) |
| for poly, region_center_coords in zip(polys, regions_center_coords): |
| x, y = region_center_coords[:, 0], region_center_coords[:, 1] |
| heatmap[y, x] = 1.0 |
|
|
| projection_points = self.get_coords_poly_projection(region_center_coords, poly) |
| offset[0, y, x] = projection_points[:, 0] - x |
| offset[1, y, x] = projection_points[:, 1] - y |
| offset_weight[y, x] = 1.0 |
|
|
| heatmap_weight = self.get_normalized_weight(heatmap, train_mask) |
| offset_weight = offset_weight * train_mask |
|
|
| return { |
| 'heatmap': heatmap[np.newaxis], |
| 'heatmap_weight': heatmap_weight[np.newaxis], |
| 'offset': offset, |
| 'offset_weight': offset_weight[np.newaxis], |
| } |
|
|
|
|
| class SimpleDetectionCropper(Configurable): |
| patch_cropper = State() |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
|
|
| def crop(self, batch, output): |
| img, label, meta = batch |
|
|
| images_polys = [] |
| images_patches = [] |
| for polys, image_meta in zip(output['polygons_pred'], meta): |
| image_meta = pickle.loads(image_meta) |
|
|
| images_polys.append(polys) |
| images_patches.append([self.patch_cropper.crop(image_meta['image'], p) for p in polys]) |
|
|
| return images_polys, images_patches |
|
|
