def iou_rotate_calculate1(boxes1, boxes2, use_gpu=True, gpu_id=0):
# start = time.time()
if use_gpu:
ious = rbbx_overlaps(boxes1, boxes2, gpu_id)
else:
area1 = boxes1[:, 2] * boxes1[:, 3]
area2 = boxes2[:, 2] * boxes2[:, 3]
ious = []
for i, box1 in enumerate(boxes1):
temp_ious = []
r1 = ((box1[0], box1[1]), (box1[2], box1[3]), box1[4])
for j, box2 in enumerate(boxes2):
r2 = ((box2[0], box2[1]), (box2[2], box2[3]), box2[4])
int_pts = cv2.rotatedRectangleIntersection(r1, r2)[1]
if int_pts is not None:
order_pts = cv2.convexHull(int_pts, returnPoints=True)
int_area = cv2.contourArea(order_pts)
inter = int_area * 1.0 / (area1[i] + area2[j] - int_area + 1e-5)
temp_ious.append(inter)
else:
temp_ious.append(0.0)
ious.append(temp_ious)
# print('{}s'.format(time.time() - start))
return np.array(ious, dtype=np.float32)
def refine_anchor_target_layer(self,
gt_boxes_r,
gt_encode_label,
anchors,
pos_threshold,
neg_threshold,
gpu_id=0):
anchor_states = np.zeros((anchors.shape[0], ))
labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM))
if gt_boxes_r.shape[0]:
# [N, M]
# if cfgs.ANGLE_RANGE == 180:
# gt_boxes_r_ = coordinate_present_convert(gt_boxes_r[:, :-1], 1)
#
# overlaps = rbbx_overlaps(np.ascontiguousarray(anchors, dtype=np.float32),
# np.ascontiguousarray(gt_boxes_r_, dtype=np.float32), gpu_id)
# else:
overlaps = rbbx_overlaps(
np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32),
gpu_id)
# overlaps = np.clip(overlaps, 0.0, 1.0)
argmax_overlaps_inds = np.argmax(overlaps, axis=1)
max_overlaps = overlaps[np.arange(overlaps.shape[0]),
argmax_overlaps_inds]
# compute box regression targets
target_boxes = gt_boxes_r[argmax_overlaps_inds]
target_encode_label = gt_encode_label[argmax_overlaps_inds]
positive_indices = max_overlaps >= pos_threshold
ignore_indices = (max_overlaps > neg_threshold) & ~positive_indices
anchor_states[ignore_indices] = -1
anchor_states[positive_indices] = 1
# compute target class labels
labels[positive_indices,
target_boxes[positive_indices, -1].astype(int) - 1] = 1
else:
# no annotations? then everything is background
target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1]))
target_encode_label = np.zeros(
(anchors.shape[0], gt_encode_label.shape[1]))
if self.cfgs.ANGLE_RANGE == 180:
anchors = coordinate_present_convert(anchors, mode=-1)
target_boxes = coordinate_present_convert(target_boxes, mode=-1)
target_delta = bbox_transform.rbbox_transform(
ex_rois=anchors,
gt_rois=target_boxes,
scale_factors=self.cfgs.ANCHOR_SCALE_FACTORS)
return np.array(labels, np.float32), np.array(target_delta[:, :-1], np.float32), \
np.array(anchor_states, np.float32), np.array(target_boxes, np.float32), \
np.array(target_encode_label, np.float32)
def anchor_target_layer(self, gt_boxes_h_batch, gt_boxes_r_batch, anchor_batch, gpu_id=0):
all_labels, all_target_delta, all_anchor_states, all_target_boxes, all_target_encode_label = [], [], [], [], []
for i in range(self.cfgs.BATCH_SIZE):
anchors = np.array(anchor_batch[i], np.float32)
gt_boxes_h = gt_boxes_h_batch[i, :, :]
gt_boxes_r = gt_boxes_r_batch[i, :, :]
anchor_states = np.zeros((anchors.shape[0],))
labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM))
if gt_boxes_r.shape[0]:
# [N, M]
if self.cfgs.METHOD == 'H':
overlaps = bbox_overlaps(np.ascontiguousarray(anchors, dtype=np.float),
np.ascontiguousarray(gt_boxes_h, dtype=np.float))
else:
overlaps = rbbx_overlaps(np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32), gpu_id)
argmax_overlaps_inds = np.argmax(overlaps, axis=1)
max_overlaps = overlaps[np.arange(overlaps.shape[0]), argmax_overlaps_inds]
# compute box regression targets
target_boxes = gt_boxes_r[argmax_overlaps_inds]
positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD
ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD) & ~positive_indices
anchor_states[ignore_indices] = -1
anchor_states[positive_indices] = 1
# compute target class labels
labels[positive_indices, target_boxes[positive_indices, -1].astype(int) - 1] = 1
else:
# no annotations? then everything is background
target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1]))
if self.cfgs.METHOD == 'H':
x_c = (anchors[:, 2] + anchors[:, 0]) / 2
y_c = (anchors[:, 3] + anchors[:, 1]) / 2
h = anchors[:, 2] - anchors[:, 0] + 1
w = anchors[:, 3] - anchors[:, 1] + 1
theta = -90 * np.ones_like(x_c)
anchors = np.vstack([x_c, y_c, w, h, theta]).transpose()
if self.cfgs.ANGLE_RANGE == 180:
anchors = coordinate_present_convert(anchors, mode=-1)
target_boxes = coordinate_present_convert(target_boxes, mode=-1)
target_delta = bbox_transform.rbbox_transform(ex_rois=anchors, gt_rois=target_boxes)
all_labels.append(labels)
all_target_delta.append(target_delta)
all_anchor_states.append(anchor_states)
all_target_boxes.append(target_boxes)
return np.array(all_labels, np.float32), np.array(all_target_delta, np.float32), \
np.array(all_anchor_states, np.float32), np.array(all_target_boxes, np.float32), \
def anchor_target_layer(self, gt_boxes_h, gt_boxes_r, anchors, gpu_id=0):
anchor_states = np.zeros((anchors.shape[0], ))
labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM))
if gt_boxes_r.shape[0]:
# [N, M]
if self.cfgs.METHOD == 'H':
overlaps = bbox_overlaps(
np.ascontiguousarray(anchors, dtype=np.float),
np.ascontiguousarray(gt_boxes_h, dtype=np.float))
else:
overlaps = rbbx_overlaps(
np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32),
gpu_id)
argmax_overlaps_inds = np.argmax(overlaps, axis=1)
max_overlaps = overlaps[np.arange(overlaps.shape[0]),
argmax_overlaps_inds]
# compute box regression targets
target_boxes = gt_boxes_r[argmax_overlaps_inds]
positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD
ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD
) & ~positive_indices
anchor_states[ignore_indices] = -1
anchor_states[positive_indices] = 1
# compute target class labels
labels[positive_indices,
target_boxes[positive_indices, -1].astype(int) - 1] = 1
else:
# no annotations? then everything is background
target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1]))
# if self.cfgs.METHOD == 'H':
# w = anchors[:, 2] - anchors[:, 0] + 1
# h = anchors[:, 3] - anchors[:, 1] + 1
# x1 = anchors[:, 0]
# y1 = anchors[:, 1]
# x2 = anchors[:, 2]
# y2 = anchors[:, 1]
# x3 = anchors[:, 2]
# y3 = anchors[:, 3]
# x4 = anchors[:, 0]
# y4 = anchors[:, 3]
# anchors = np.stack([x1, y1, x2, y2, x3, y3, x4, y4, w, h]).transpose()
#
# target_delta = bbox_transform.qbbox_transform(ex_rois=anchors, gt_rois=target_boxes)
return np.array(labels, np.float32), np.array(
anchor_states, np.float32), np.array(target_boxes, np.float32)
def anchor_target_layer(self, gt_boxes_h, gt_boxes_r, anchors, gpu_id=0):
anchor_states = np.zeros((anchors.shape[0], ))
labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM))
if gt_boxes_r.shape[0]:
# [N, M]
if self.cfgs.METHOD == 'H':
overlaps = bbox_overlaps(
np.ascontiguousarray(anchors, dtype=np.float),
np.ascontiguousarray(gt_boxes_h, dtype=np.float))
else:
overlaps = rbbx_overlaps(
np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32),
gpu_id)
argmax_overlaps_inds = np.argmax(overlaps, axis=1)
max_overlaps = overlaps[np.arange(overlaps.shape[0]),
argmax_overlaps_inds]
# compute box regression targets
target_boxes = gt_boxes_r[argmax_overlaps_inds]
positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD
ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD
) & ~positive_indices
anchor_states[ignore_indices] = -1
anchor_states[positive_indices] = 1
# compute target class labels
labels[positive_indices,
target_boxes[positive_indices, -1].astype(int) - 1] = 1
else:
# no annotations? then everything is background
target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1]))
if self.cfgs.METHOD == 'H':
x_c = (anchors[:, 2] + anchors[:, 0]) / 2
y_c = (anchors[:, 3] + anchors[:, 1]) / 2
h = anchors[:, 2] - anchors[:, 0] + 1
w = anchors[:, 3] - anchors[:, 1] + 1
theta = -90 * np.ones_like(x_c)
anchors = np.vstack([x_c, y_c, w, h, theta]).transpose()
target_delta = bbox_transform.rbbox_transform(ex_rois=anchors,
gt_rois=target_boxes)
return np.array(labels, np.float32), np.array(target_delta, np.float32), \
np.array(anchor_states, np.float32), np.array(target_boxes, np.float32)
def refine_anchor_target_layer(self,
gt_boxes_r,
anchors,
pos_threshold,
neg_threshold,
gpu_id=0):
anchor_states = np.zeros((anchors.shape[0], ))
labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM))
if gt_boxes_r.shape[0]:
# [N, M]
# overlaps = get_iou_matrix(np.ascontiguousarray(anchors, dtype=np.float32),
# np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32))
#
overlaps = rbbx_overlaps(
np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32),
gpu_id)
argmax_overlaps_inds = np.argmax(overlaps, axis=1)
max_overlaps = overlaps[np.arange(overlaps.shape[0]),
argmax_overlaps_inds]
# compute box regression targets
target_boxes = gt_boxes_r[argmax_overlaps_inds]
positive_indices = max_overlaps >= pos_threshold
ignore_indices = (max_overlaps > neg_threshold) & ~positive_indices
anchor_states[ignore_indices] = -1
anchor_states[positive_indices] = 1
# compute target class labels
labels[positive_indices,
target_boxes[positive_indices, -1].astype(int) - 1] = 1
else:
# no annotations? then everything is background
target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1]))
target_delta = bbox_transform.rbbox_transform(
ex_rois=anchors,
gt_rois=target_boxes,
scale_factors=self.cfgs.ANCHOR_SCALE_FACTORS)
return np.array(labels, np.float32), np.array(target_delta, np.float32), \
np.array(anchor_states, np.float32), np.array(target_boxes, np.float32)
# ar = (8 / (math.pi ** 2)) * (np.arctan(boxes1[:, 2]/boxes1[:, 3]) - np.arctan(boxes2[:, 2]/boxes2[:, 3])) \
# * ((boxes1[:, 2] - w_temp) * boxes1[:, 3])
# cious = ious - d / c - alpha * ar
cious = (ious - d / c) * np.abs(np.cos(boxes1[:, 4] - boxes2[:, 4]))
else:
cious = []
return np.reshape(np.array(cious, dtype=np.float32), [-1, 1])
if __name__ == '__main__':
boxes1 = np.array([
[150, 150, 1e-15, 5, -45],
], np.float32)
boxes2 = np.array([
[50, 50, 5, 1e-15, -45]], np.float32)
from libs.box_utils.overlaps_cython.overlaps_cython import rbox_overlaps
overlaps = rbox_overlaps(np.array(boxes1, dtype=np.float32),
np.array(boxes2, dtype=np.float32))
print(overlaps)
print(rbbx_overlaps(boxes1, boxes2, 3))