Spaces:
Sleeping
Sleeping
| import math | |
| import random | |
| import cv2 | |
| import numpy as np | |
| from ..augmentations import box_candidates | |
| from ..general import resample_segments, segment2box | |
| from ..metrics import bbox_ioa | |
| def mixup(im, labels, segments, seg_cls, semantic_masks, im2, labels2, segments2, seg_cls2, semantic_masks2): | |
| # Applies MixUp augmentation https://arxiv.org/pdf/1710.09412.pdf | |
| r = np.random.beta(32.0, 32.0) # mixup ratio, alpha=beta=32.0 | |
| im = (im * r + im2 * (1 - r)).astype(np.uint8) | |
| labels = np.concatenate((labels, labels2), 0) | |
| segments = np.concatenate((segments, segments2), 0) | |
| seg_cls = np.concatenate((seg_cls, seg_cls2), 0) | |
| semantic_masks = np.concatenate((semantic_masks, semantic_masks2), 0) | |
| return im, labels, segments, seg_cls, semantic_masks | |
| def random_perspective(im, | |
| targets=(), | |
| segments=(), | |
| semantic_masks = (), | |
| degrees=10, | |
| translate=.1, | |
| scale=.1, | |
| shear=10, | |
| perspective=0.0, | |
| border=(0, 0)): | |
| # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10)) | |
| # targets = [cls, xyxy] | |
| height = im.shape[0] + border[0] * 2 # shape(h,w,c) | |
| width = im.shape[1] + border[1] * 2 | |
| # Center | |
| C = np.eye(3) | |
| C[0, 2] = -im.shape[1] / 2 # x translation (pixels) | |
| C[1, 2] = -im.shape[0] / 2 # y translation (pixels) | |
| # Perspective | |
| P = np.eye(3) | |
| P[2, 0] = random.uniform(-perspective, perspective) # x perspective (about y) | |
| P[2, 1] = random.uniform(-perspective, perspective) # y perspective (about x) | |
| # Rotation and Scale | |
| R = np.eye(3) | |
| a = random.uniform(-degrees, degrees) | |
| # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations | |
| s = random.uniform(1 - scale, 1 + scale) | |
| # s = 2 ** random.uniform(-scale, scale) | |
| R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s) | |
| # Shear | |
| S = np.eye(3) | |
| S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # x shear (deg) | |
| S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # y shear (deg) | |
| # Translation | |
| T = np.eye(3) | |
| T[0, 2] = (random.uniform(0.5 - translate, 0.5 + translate) * width) # x translation (pixels) | |
| T[1, 2] = (random.uniform(0.5 - translate, 0.5 + translate) * height) # y translation (pixels) | |
| # Combined rotation matrix | |
| M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT | |
| if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed | |
| if perspective: | |
| im = cv2.warpPerspective(im, M, dsize=(width, height), borderValue=(114, 114, 114)) | |
| else: # affine | |
| im = cv2.warpAffine(im, M[:2], dsize=(width, height), borderValue=(114, 114, 114)) | |
| # Visualize | |
| # import matplotlib.pyplot as plt | |
| # ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel() | |
| # ax[0].imshow(im[:, :, ::-1]) # base | |
| # ax[1].imshow(im2[:, :, ::-1]) # warped | |
| # Transform label coordinates | |
| n = len(targets) | |
| new_segments = [] | |
| new_semantic_masks = [] | |
| if n: | |
| new = np.zeros((n, 4)) | |
| segments = resample_segments(segments) # upsample | |
| for i, segment in enumerate(segments): | |
| xy = np.ones((len(segment), 3)) | |
| xy[:, :2] = segment | |
| xy = xy @ M.T # transform | |
| xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]) # perspective rescale or affine | |
| # clip | |
| new[i] = segment2box(xy, width, height) | |
| new_segments.append(xy) | |
| semantic_masks = resample_segments(semantic_masks) | |
| for i, semantic_mask in enumerate(semantic_masks): | |
| #if i < n: | |
| # xy = np.ones((len(segments[i]), 3)) | |
| # xy[:, :2] = segments[i] | |
| # xy = xy @ M.T # transform | |
| # xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]) # perspective rescale or affine | |
| # new[i] = segment2box(xy, width, height) | |
| # new_segments.append(xy) | |
| xy_s = np.ones((len(semantic_mask), 3)) | |
| xy_s[:, :2] = semantic_mask | |
| xy_s = xy_s @ M.T # transform | |
| xy_s = (xy_s[:, :2] / xy_s[:, 2:3] if perspective else xy_s[:, :2]) # perspective rescale or affine | |
| new_semantic_masks.append(xy_s) | |
| # filter candidates | |
| i = box_candidates(box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01) | |
| targets = targets[i] | |
| targets[:, 1:5] = new[i] | |
| new_segments = np.array(new_segments)[i] | |
| new_semantic_masks = np.array(new_semantic_masks) | |
| return im, targets, new_segments, new_semantic_masks | |
| def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32): | |
| # Resize and pad image while meeting stride-multiple constraints | |
| shape = im.shape[:2] # current shape [height, width] | |
| if isinstance(new_shape, int): | |
| new_shape = (new_shape, new_shape) | |
| # Scale ratio (new / old) | |
| r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) | |
| if not scaleup: # only scale down, do not scale up (for better val mAP) | |
| r = min(r, 1.0) | |
| # Compute padding | |
| ratio = r, r # width, height ratios | |
| new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) | |
| dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding | |
| if auto: # minimum rectangle | |
| dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding | |
| elif scaleFill: # stretch | |
| dw, dh = 0.0, 0.0 | |
| new_unpad = (new_shape[1], new_shape[0]) | |
| ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios | |
| dw /= 2 # divide padding into 2 sides | |
| dh /= 2 | |
| if shape[::-1] != new_unpad: # resize | |
| im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR) | |
| top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) | |
| left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) | |
| im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border | |
| return im, ratio, (dw, dh) | |
| def copy_paste(im, labels, segments, seg_cls, semantic_masks, p=0.5): | |
| # Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy) | |
| n = len(segments) | |
| if p and n: | |
| h, w, _ = im.shape # height, width, channels | |
| im_new = np.zeros(im.shape, np.uint8) | |
| # calculate ioa first then select indexes randomly | |
| boxes = np.stack([w - labels[:, 3], labels[:, 2], w - labels[:, 1], labels[:, 4]], axis=-1) # (n, 4) | |
| ioa = bbox_ioa(boxes, labels[:, 1:5]) # intersection over area | |
| indexes = np.nonzero((ioa < 0.30).all(1))[0] # (N, ) | |
| n = len(indexes) | |
| for j in random.sample(list(indexes), k=round(p * n)): | |
| l, box, s = labels[j], boxes[j], segments[j] | |
| labels = np.concatenate((labels, [[l[0], *box]]), 0) | |
| segments.append(np.concatenate((w - s[:, 0:1], s[:, 1:2]), 1)) | |
| seg_cls.append(l[0].astype(int)) | |
| semantic_masks.append(np.concatenate((w - s[:, 0:1], s[:, 1:2]), 1)) | |
| cv2.drawContours(im_new, [segments[j].astype(np.int32)], -1, (1, 1, 1), cv2.FILLED) | |
| result = cv2.flip(im, 1) # augment segments (flip left-right) | |
| i = cv2.flip(im_new, 1).astype(bool) | |
| im[i] = result[i] # cv2.imwrite('debug.jpg', im) # debug | |
| return im, labels, segments, seg_cls, semantic_masks |