Spaces:
Running
Running
| import numpy as np | |
| from .boxes_utils import assert_and_normalize_shape | |
| def rotate_boxes(boxes, angle, x_center=0, y_center=0, scale=1, | |
| degrees=True, return_rotated_boxes=False): | |
| """ | |
| Args: | |
| boxes: (N, 4+K) | |
| angle: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| x_center: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| y_center: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| scale: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| scale factor in x and y dimension | |
| degrees: bool | |
| return_rotated_boxes: bool | |
| """ | |
| boxes = np.asarray(boxes, np.float32) | |
| angle = np.asarray(angle, np.float32) | |
| x_center = np.asarray(x_center, np.float32) | |
| y_center = np.asarray(y_center, np.float32) | |
| scale = np.asarray(scale, np.float32) | |
| angle = assert_and_normalize_shape(angle, boxes.shape[0]) | |
| x_center = assert_and_normalize_shape(x_center, boxes.shape[0]) | |
| y_center = assert_and_normalize_shape(y_center, boxes.shape[0]) | |
| scale = assert_and_normalize_shape(scale, boxes.shape[0]) | |
| if degrees: | |
| angle = np.deg2rad(angle) | |
| cos_val = scale * np.cos(angle) | |
| sin_val = scale * np.sin(angle) | |
| x_shift = x_center - x_center * cos_val + y_center * sin_val | |
| y_shift = y_center - x_center * sin_val - y_center * cos_val | |
| x_mins, y_mins = boxes[:,0], boxes[:,1] | |
| x_maxs, y_maxs = boxes[:,2], boxes[:,3] | |
| x00 = x_mins * cos_val - y_mins * sin_val + x_shift | |
| x10 = x_maxs * cos_val - y_mins * sin_val + x_shift | |
| x11 = x_maxs * cos_val - y_maxs * sin_val + x_shift | |
| x01 = x_mins * cos_val - y_maxs * sin_val + x_shift | |
| y00 = x_mins * sin_val + y_mins * cos_val + y_shift | |
| y10 = x_maxs * sin_val + y_mins * cos_val + y_shift | |
| y11 = x_maxs * sin_val + y_maxs * cos_val + y_shift | |
| y01 = x_mins * sin_val + y_maxs * cos_val + y_shift | |
| rotated_boxes = np.stack([x00, y00, x10, y10, x11, y11, x01, y01], axis=-1) | |
| ret_x_mins = np.min(rotated_boxes[:,0::2], axis=1) | |
| ret_y_mins = np.min(rotated_boxes[:,1::2], axis=1) | |
| ret_x_maxs = np.max(rotated_boxes[:,0::2], axis=1) | |
| ret_y_maxs = np.max(rotated_boxes[:,1::2], axis=1) | |
| if boxes.ndim == 4: | |
| ret_boxes = np.stack([ret_x_mins, ret_y_mins, ret_x_maxs, ret_y_maxs], axis=-1) | |
| else: | |
| ret_boxes = boxes.copy() | |
| ret_boxes[:, :4] = np.stack([ret_x_mins, ret_y_mins, ret_x_maxs, ret_y_maxs], axis=-1) | |
| if not return_rotated_boxes: | |
| return ret_boxes | |
| else: | |
| return ret_boxes, rotated_boxes | |
| def rotate_boxes_wrt_centers(boxes, angle, scale=1, degrees=True, | |
| return_rotated_boxes=False): | |
| """ | |
| Args: | |
| boxes: (N, 4+K) | |
| angle: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| scale: array-like whose shape is (), (1,), (N,), (1, 1) or (N, 1) | |
| scale factor in x and y dimension | |
| degrees: bool | |
| return_rotated_boxes: bool | |
| """ | |
| boxes = np.asarray(boxes, np.float32) | |
| angle = np.asarray(angle, np.float32) | |
| scale = np.asarray(scale, np.float32) | |
| angle = assert_and_normalize_shape(angle, boxes.shape[0]) | |
| scale = assert_and_normalize_shape(scale, boxes.shape[0]) | |
| if degrees: | |
| angle = np.deg2rad(angle) | |
| cos_val = scale * np.cos(angle) | |
| sin_val = scale * np.sin(angle) | |
| x_centers = boxes[:, 2] + boxes[:, 0] | |
| y_centers = boxes[:, 3] + boxes[:, 1] | |
| x_centers *= 0.5 | |
| y_centers *= 0.5 | |
| half_widths = boxes[:, 2] - boxes[:, 0] | |
| half_heights = boxes[:, 3] - boxes[:, 1] | |
| half_widths *= 0.5 | |
| half_heights *= 0.5 | |
| half_widths_cos = half_widths * cos_val | |
| half_widths_sin = half_widths * sin_val | |
| half_heights_cos = half_heights * cos_val | |
| half_heights_sin = half_heights * sin_val | |
| x00 = -half_widths_cos + half_heights_sin | |
| x10 = half_widths_cos + half_heights_sin | |
| x11 = half_widths_cos - half_heights_sin | |
| x01 = -half_widths_cos - half_heights_sin | |
| x00 += x_centers | |
| x10 += x_centers | |
| x11 += x_centers | |
| x01 += x_centers | |
| y00 = -half_widths_sin - half_heights_cos | |
| y10 = half_widths_sin - half_heights_cos | |
| y11 = half_widths_sin + half_heights_cos | |
| y01 = -half_widths_sin + half_heights_cos | |
| y00 += y_centers | |
| y10 += y_centers | |
| y11 += y_centers | |
| y01 += y_centers | |
| rotated_boxes = np.stack([x00, y00, x10, y10, x11, y11, x01, y01], axis=-1) | |
| ret_x_mins = np.min(rotated_boxes[:,0::2], axis=1) | |
| ret_y_mins = np.min(rotated_boxes[:,1::2], axis=1) | |
| ret_x_maxs = np.max(rotated_boxes[:,0::2], axis=1) | |
| ret_y_maxs = np.max(rotated_boxes[:,1::2], axis=1) | |
| if boxes.ndim == 4: | |
| ret_boxes = np.stack([ret_x_mins, ret_y_mins, ret_x_maxs, ret_y_maxs], axis=-1) | |
| else: | |
| ret_boxes = boxes.copy() | |
| ret_boxes[:, :4] = np.stack([ret_x_mins, ret_y_mins, ret_x_maxs, ret_y_maxs], axis=-1) | |
| if not return_rotated_boxes: | |
| return ret_boxes | |
| else: | |
| return ret_boxes, rotated_boxes | |