def filter_detections(boxes, scores, is_training): """ :param boxes: [-1, 4] :param scores: [-1, ] :param labels: [-1, ] :return: """ if is_training: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [-1, ]) else: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [-1, ]) if cfgs.NMS: filtered_boxes = tf.gather(boxes, indices) filtered_scores = tf.gather(scores, indices) # perform NMS nms_indices = nms_rotate.nms_rotate(decode_boxes=filtered_boxes, scores=filtered_scores, iou_threshold=cfgs.NMS_IOU_THRESHOLD, max_output_size=100, use_angle_condition=False, angle_threshold=15, use_gpu=False) # filter indices based on NMS indices = tf.gather(indices, nms_indices) # add indices to list of all indices return indices
def fast_rcnn_proposals_rotate(self, decode_boxes, scores): ''' mutilclass NMS :param decode_boxes: [N, num_classes*5] :param scores: [N, num_classes+1] :return: detection_boxes : [-1, 5] scores : [-1, ] ''' with tf.variable_scope('fast_rcnn_proposals'): category = tf.argmax(scores, axis=1) object_mask = tf.cast(tf.not_equal(category, 0), tf.float32) decode_boxes = decode_boxes * tf.expand_dims(object_mask, axis=1) # make background box is [0 0 0 0, 0] scores = scores * tf.expand_dims(object_mask, axis=1) decode_boxes = tf.reshape(decode_boxes, [-1, self.num_classes, 5]) # [N, num_classes, 5] decode_boxes_list = tf.unstack(decode_boxes, axis=1) score_list = tf.unstack(scores[:, 1:], axis=1) after_nms_boxes = [] after_nms_scores = [] category_list = [] for per_class_decode_boxes, per_class_scores in zip(decode_boxes_list, score_list): valid_indices = nms_rotate.nms_rotate(decode_boxes=per_class_decode_boxes, scores=per_class_scores, iou_threshold=self.fast_rcnn_nms_iou_threshold, max_output_size=self.fast_rcnn_nms_max_boxes_per_class, use_angle_condition=False, angle_threshold=15, use_gpu=cfgs.ROTATE_NMS_USE_GPU) after_nms_boxes.append(tf.gather(per_class_decode_boxes, valid_indices)) after_nms_scores.append(tf.gather(per_class_scores, valid_indices)) tmp_category = tf.gather(category, valid_indices) category_list.append(tmp_category) all_nms_boxes = tf.concat(after_nms_boxes, axis=0) all_nms_scores = tf.concat(after_nms_scores, axis=0) all_category = tf.concat(category_list, axis=0) # all_nms_boxes = boxes_utils.clip_boxes_to_img_boundaries(all_nms_boxes, # img_shape=self.img_shape) scores_large_than_threshold_indices = \ tf.reshape(tf.where(tf.greater(all_nms_scores, self.show_detections_score_threshold)), [-1]) all_nms_boxes = tf.gather(all_nms_boxes, scores_large_than_threshold_indices) all_nms_scores = tf.gather(all_nms_scores, scores_large_than_threshold_indices) all_category = tf.gather(all_category, scores_large_than_threshold_indices) return all_nms_boxes, all_nms_scores, tf.shape(all_nms_boxes)[0], all_category
def filter_detections(boxes, scores, is_training, gpu_id): """ :param boxes: [-1, 4] :param scores: [-1, ] :param labels: [-1, ] :return: """ if is_training: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [ -1, ]) else: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [ -1, ]) if cfgs.NMS: filtered_boxes = tf.gather(boxes, indices) filtered_scores = tf.gather(scores, indices) if cfgs.ANGLE_RANGE == 180: # _, _, _, _, theta = tf.unstack(boxes_pred, axis=1) # indx = tf.reshape(tf.where(tf.logical_and(tf.less(theta, 0), tf.greater_equal(theta, -180))), [-1, ]) # boxes_pred = tf.gather(boxes_pred, indx) # scores = tf.gather(scores, indx) filtered_boxes = tf.py_func(coordinate_present_convert, inp=[filtered_boxes, 1], Tout=[tf.float32]) filtered_boxes = tf.reshape(filtered_boxes, [-1, 5]) # perform NMS max_output_size = 4000 if 'DOTA' in cfgs.NET_NAME else 200 nms_indices = nms_rotate.nms_rotate( decode_boxes=filtered_boxes, scores=filtered_scores, iou_threshold=cfgs.NMS_IOU_THRESHOLD, max_output_size=100 if is_training else max_output_size, use_angle_condition=False, angle_threshold=15, use_gpu=True, gpu_id=gpu_id) # filter indices based on NMS indices = tf.gather(indices, nms_indices) # add indices to list of all indices return indices
def postprocess_detctions(rpn_bbox_pred, rpn_cls_prob, rpn_angle_prob, anchors, is_training): # return_boxes_pred = [] return_boxes_pred_angle = [] return_scores = [] return_labels = [] for j in range(0, cfgs.CLASS_NUM): scores = rpn_cls_prob[:, j] if is_training: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [ -1, ]) else: indices = tf.reshape( tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [ -1, ]) anchors_ = tf.gather(anchors, indices) rpn_bbox_pred_ = tf.gather(rpn_bbox_pred, indices) scores = tf.gather(scores, indices) rpn_angle_prob_ = tf.gather(rpn_angle_prob, indices) angle_cls = tf.py_func(angle_label_decode, inp=[ rpn_angle_prob_, cfgs.ANGLE_RANGE, cfgs.OMEGA, cfgs.ANGLE_MODE ], Tout=[tf.float32]) angle_cls = tf.reshape(angle_cls, [ -1, ]) * -1 if 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 * tf.ones_like(x_c) anchors_ = tf.transpose(tf.stack([x_c, y_c, w, h, theta])) if cfgs.ANGLE_RANGE == 180: anchors_ = tf.py_func(coordinate_present_convert, inp=[anchors_, -1], Tout=[tf.float32]) anchors_ = tf.reshape(anchors_, [-1, 5]) boxes_pred = bbox_transform.rbbox_transform_inv_dcl( boxes=anchors_, deltas=rpn_bbox_pred_) boxes_pred = tf.reshape(boxes_pred, [-1, 4]) x, y, w, h = tf.unstack(boxes_pred, axis=1) boxes_pred_angle = tf.transpose(tf.stack([x, y, w, h, angle_cls])) if cfgs.ANGLE_RANGE == 180: # _, _, _, _, theta = tf.unstack(boxes_pred, axis=1) # indx = tf.reshape(tf.where(tf.logical_and(tf.less(theta, 0), tf.greater_equal(theta, -180))), [-1, ]) # boxes_pred = tf.gather(boxes_pred, indx) # scores = tf.gather(scores, indx) # boxes_pred = tf.py_func(coordinate_present_convert, # inp=[boxes_pred, 1], # Tout=[tf.float32]) # boxes_pred = tf.reshape(boxes_pred, [-1, 5]) boxes_pred_angle = tf.py_func(coordinate_present_convert, inp=[boxes_pred_angle, 1], Tout=[tf.float32]) boxes_pred_angle = tf.reshape(boxes_pred_angle, [-1, 5]) nms_indices = nms_rotate.nms_rotate( decode_boxes=boxes_pred_angle, scores=scores, iou_threshold=cfgs.NMS_IOU_THRESHOLD, max_output_size=100 if is_training else 1000, use_angle_condition=False, angle_threshold=15, use_gpu=False) # tmp_boxes_pred = tf.reshape(tf.gather(boxes_pred, nms_indices), [-1, 5]) tmp_boxes_pred_angle = tf.reshape( tf.gather(boxes_pred_angle, nms_indices), [-1, 5]) tmp_scores = tf.reshape(tf.gather(scores, nms_indices), [ -1, ]) # return_boxes_pred.append(tmp_boxes_pred) return_boxes_pred_angle.append(tmp_boxes_pred_angle) return_scores.append(tmp_scores) return_labels.append(tf.ones_like(tmp_scores) * (j + 1)) # return_boxes_pred = tf.concat(return_boxes_pred, axis=0) return_boxes_pred_angle = tf.concat(return_boxes_pred_angle, axis=0) return_scores = tf.concat(return_scores, axis=0) return_labels = tf.concat(return_labels, axis=0) return return_scores, return_labels, return_boxes_pred_angle
def postprocess_fastrcnn(self, rois, bbox_ppred, scores, img_shape): ''' :param rois:[-1, 4] :param bbox_ppred: [-1, (cfgs.Class_num+1) * 5] :param scores: [-1, cfgs.Class_num + 1] :return: ''' with tf.name_scope('postprocess_fastrcnn'): rois = tf.stop_gradient(rois) scores = tf.stop_gradient(scores) bbox_ppred = tf.reshape(bbox_ppred, [-1, cfgs.CLASS_NUM + 1, 5]) bbox_ppred = tf.stop_gradient(bbox_ppred) bbox_pred_list = tf.unstack(bbox_ppred, axis=1) score_list = tf.unstack(scores, axis=1) allclasses_boxes = [] allclasses_scores = [] categories = [] for i in range(1, cfgs.CLASS_NUM+1): # 1. decode boxes in each class tmp_encoded_box = bbox_pred_list[i] tmp_score = score_list[i] tmp_decoded_boxes = encode_and_decode.decode_boxes_rotate(encode_boxes=tmp_encoded_box, reference_boxes=rois, scale_factors=cfgs.ROI_SCALE_FACTORS) # tmp_decoded_boxes = encode_and_decode.decode_boxes(boxes=rois, # deltas=tmp_encoded_box, # scale_factor=cfgs.ROI_SCALE_FACTORS) # 2. clip to img boundaries # tmp_decoded_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=tmp_decoded_boxes, # img_shape=img_shape) # 3. NMS keep = nms_rotate.nms_rotate(decode_boxes=tmp_decoded_boxes, scores=tmp_score, iou_threshold=cfgs.FAST_RCNN_NMS_IOU_THRESHOLD, max_output_size=cfgs.FAST_RCNN_NMS_MAX_BOXES_PER_CLASS, use_angle_condition=False, angle_threshold=15, use_gpu=True) perclass_boxes = tf.gather(tmp_decoded_boxes, keep) perclass_scores = tf.gather(tmp_score, keep) allclasses_boxes.append(perclass_boxes) allclasses_scores.append(perclass_scores) categories.append(tf.ones_like(perclass_scores) * i) final_boxes = tf.concat(allclasses_boxes, axis=0) final_scores = tf.concat(allclasses_scores, axis=0) final_category = tf.concat(categories, axis=0) # if self.is_training: ''' in training. We should show the detecitons in the tensorboard. So we add this. ''' kept_indices = tf.reshape(tf.where(tf.greater_equal(final_scores, cfgs.SHOW_SCORE_THRSHOLD)), [-1]) final_boxes = tf.gather(final_boxes, kept_indices) final_scores = tf.gather(final_scores, kept_indices) final_category = tf.gather(final_category, kept_indices) return final_boxes, final_scores, final_category
def rpn_proposals(self): with tf.variable_scope('rpn_proposals'): rpn_decode_boxes = encode_and_decode.decode_boxes( encode_boxes=self.rpn_encode_boxes, reference_boxes=self.anchors, scale_factors=self.scale_factors) # if not self.is_training: # when test, clip proposals to img boundaries # img_shape = tf.shape(self.img_batch) # rpn_decode_boxes = boxes_utils.clip_boxes_to_img_boundaries(rpn_decode_boxes, img_shape) rpn_softmax_scores = slim.softmax(self.rpn_scores) rpn_object_score = rpn_softmax_scores[:, 1] # second column represent object if self.top_k_nms: rpn_object_score, top_k_indices = tf.nn.top_k(rpn_object_score, k=self.top_k_nms) rpn_decode_boxes = tf.gather(rpn_decode_boxes, top_k_indices) if not cfgs.USE_HORIZONTAL_NMS: valid_indices = nms_rotate.nms_rotate( decode_boxes=rpn_decode_boxes, scores=rpn_object_score, iou_threshold=self.rpn_nms_iou_threshold, max_output_size=self.max_proposals_num, use_angle_condition=self.use_angles_condition, angle_threshold=self.anchor_angle_threshold, use_gpu=cfgs.NMS_USE_GPU) ############################################################################################################ else: rpn_decode_boxes_convert = tf.py_func( coordinate_convert.forward_convert, inp=[rpn_decode_boxes], Tout=tf.float32) rpn_decode_boxes_convert = tf.reshape( rpn_decode_boxes_convert, [tf.shape(rpn_decode_boxes)[0], 8]) x1, y1, x2, y2, x3, y3, x4, y4 = tf.unstack( rpn_decode_boxes_convert, axis=1) x = tf.transpose(tf.stack([x1, x2, x3, x4])) y = tf.transpose(tf.stack([y1, y2, y3, y4])) min_x = tf.reduce_min(x, axis=1) max_x = tf.reduce_max(x, axis=1) min_y = tf.reduce_min(y, axis=1) max_y = tf.reduce_max(y, axis=1) rpn_decode_boxes_convert = tf.transpose( tf.stack([min_x, min_y, max_x, max_y])) valid_indices = tf.image.non_max_suppression( boxes=rpn_decode_boxes_convert, scores=rpn_object_score, max_output_size=self.max_proposals_num, iou_threshold=self.rpn_nms_iou_threshold, name='rpn_horizontal_nms') ############################################################################################################ valid_boxes = tf.gather(rpn_decode_boxes, valid_indices) valid_scores = tf.gather(rpn_object_score, valid_indices) rpn_proposals_boxes, rpn_proposals_scores = tf.cond( tf.less(tf.shape(valid_boxes)[0], self.max_proposals_num), lambda: boxes_utils.padd_boxes_with_zeros( valid_boxes, valid_scores, self.max_proposals_num), lambda: (valid_boxes, valid_scores)) return rpn_proposals_boxes, rpn_proposals_scores
def postprocess_fastrcnn(self, rois, bbox_ppred, scores, gpu_id): ''' :param rois:[-1, 4] :param bbox_ppred: [-1, (cfgs.Class_num+1) * 5] :param scores: [-1, cfgs.Class_num + 1] :return: ''' with tf.name_scope('postprocess_fastrcnn'): rois = tf.stop_gradient(rois) scores = tf.stop_gradient(scores) bbox_ppred = tf.reshape(bbox_ppred, [-1, cfgs.CLASS_NUM + 1, 5]) bbox_ppred = tf.stop_gradient(bbox_ppred) bbox_pred_list = tf.unstack(bbox_ppred, axis=1) score_list = tf.unstack(scores, axis=1) allclasses_boxes = [] allclasses_scores = [] categories = [] for i in range(1, cfgs.CLASS_NUM + 1): # 1. decode boxes in each class tmp_encoded_box = bbox_pred_list[i] tmp_score = score_list[i] tmp_decoded_boxes = encode_and_decode.decode_boxes_rotate( encode_boxes=tmp_encoded_box, reference_boxes=rois, scale_factors=cfgs.ROI_SCALE_FACTORS) # tmp_decoded_boxes = encode_and_decode.decode_boxes(boxes=rois, # deltas=tmp_encoded_box, # scale_factor=cfgs.ROI_SCALE_FACTORS) # 2. clip to img boundaries # tmp_decoded_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=tmp_decoded_boxes, # img_shape=img_shape) threshold = { 'roundabout': 0.3, 'tennis-court': 0.3, 'swimming-pool': 0.3, 'storage-tank': 0.2, 'soccer-ball-field': 0.3, 'small-vehicle': 0.3, 'ship': 0.1, 'plane': 0.3, 'large-vehicle': 0.15, 'helicopter': 0.3, 'harbor': 0.1, 'ground-track-field': 0.3, 'bridge': 0.1, 'basketball-court': 0.3, 'baseball-diamond': 0.3, 'container-crane': 0.3 } # 3. NMS if cfgs.SOFT_NMS: print("Using Soft NMS.......") raise NotImplementedError( "soft NMS for rotate has not implemented") else: keep = nms_rotate.nms_rotate( decode_boxes=tmp_decoded_boxes, scores=tmp_score, iou_threshold=threshold[LABEL_NAME_MAP[i]], max_output_size=cfgs.FAST_RCNN_NMS_MAX_BOXES_PER_CLASS, use_angle_condition=False, angle_threshold=15, use_gpu=cfgs.ROTATE_NMS_USE_GPU, gpu_id=gpu_id) perclass_boxes = tf.gather(tmp_decoded_boxes, keep) perclass_scores = tf.gather(tmp_score, keep) allclasses_boxes.append(perclass_boxes) allclasses_scores.append(perclass_scores) categories.append(tf.ones_like(perclass_scores) * i) final_boxes = tf.concat(allclasses_boxes, axis=0) final_scores = tf.concat(allclasses_scores, axis=0) final_category = tf.concat(categories, axis=0) if self.is_training: ''' in training. We should show the detecitons in the tensorboard. So we add this. ''' kept_indices = tf.reshape( tf.where( tf.greater_equal(final_scores, cfgs.SHOW_SCORE_THRSHOLD)), [-1]) final_boxes = tf.gather(final_boxes, kept_indices) final_scores = tf.gather(final_scores, kept_indices) final_category = tf.gather(final_category, kept_indices) return final_boxes, final_scores, final_category
def postprocess_rpn_proposals(rpn_bbox_pred, rpn_cls_prob, img_shape, anchors, is_training): ''' :param rpn_bbox_pred: [-1, 4] :param rpn_cls_prob: [-1, 2] :param img_shape: :param anchors:[-1, 4] :param is_training: :return: ''' if is_training: pre_nms_topN = cfgs.RPN_TOP_K_NMS_TRAIN post_nms_topN = cfgs.RPN_MAXIMUM_PROPOSAL_TARIN nms_thresh = cfgs.RPN_NMS_IOU_THRESHOLD else: pre_nms_topN = cfgs.RPN_TOP_K_NMS_TEST post_nms_topN = cfgs.RPN_MAXIMUM_PROPOSAL_TEST nms_thresh = cfgs.RPN_NMS_IOU_THRESHOLD cls_prob = rpn_cls_prob[:, 1] # 1. decode boxes decode_boxes = encode_and_decode.decode_boxes_rotate( encode_boxes=rpn_bbox_pred, reference_boxes=anchors, scale_factors=cfgs.ANCHOR_SCALE_FACTORS) # decode_boxes = encode_and_decode.decode_boxes(boxes=anchors, # deltas=rpn_bbox_pred, # scale_factor=None) # 2. clip to img boundaries # decode_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=decode_boxes, # img_shape=img_shape) # 3. get top N to NMS if pre_nms_topN > 0: pre_nms_topN = tf.minimum(pre_nms_topN, tf.shape(decode_boxes)[0], name='avoid_unenough_boxes') cls_prob, top_k_indices = tf.nn.top_k(cls_prob, k=pre_nms_topN) decode_boxes = tf.gather(decode_boxes, top_k_indices) # 4. NMS # keep = tf.image.non_max_suppression(boxes=decode_boxes, # scores=cls_prob, # max_output_size=post_nms_topN, # iou_threshold=nms_thresh) keep = nms_rotate.nms_rotate(decode_boxes=decode_boxes, scores=cls_prob, iou_threshold=nms_thresh, max_output_size=post_nms_topN, use_angle_condition=False, angle_threshold=15, use_gpu=True) final_boxes = tf.gather(decode_boxes, keep) final_probs = tf.gather(cls_prob, keep) return final_boxes, final_probs
def fast_rcnn_proposals_rotate(self, decode_boxes, scores, head_quadrant): ''' mutilclass NMS :param decode_boxes: [N, num_classes*5] :param scores: [N, num_classes+1] :return: detection_boxes : [-1, 5] scores : [-1, ] ''' with tf.variable_scope('fast_rcnn_proposals'): category = tf.argmax(scores, axis=1) object_mask = tf.cast(tf.not_equal(category, 0), tf.float32) decode_boxes = decode_boxes * tf.expand_dims( object_mask, axis=1) # make background box is [0 0 0 0, 0] scores = scores * tf.expand_dims(object_mask, axis=1) # Class-agnostic regression # decode_boxes = tf.reshape(decode_boxes, [-1, self.num_classes, 5]) # [N, num_classes, 5] # head_quadrant = tf.reshape(head_quadrant, [-1, self.num_classes, 4]) # decode_boxes_list = tf.unstack(decode_boxes, axis=1) # head_quadrant_list = tf.unstack(head_quadrant, axis=1) # score_list = tf.unstack(scores[:, 1:], axis=1) # after_nms_boxes = [] # after_nms_scores = [] # after_nms_head_quadrant = [] # category_list = [] # for per_class_decode_boxes, per_head_quadrant, per_class_scores in zip(decode_boxes_list, head_quadrant_list, score_list): # valid_indices = nms_rotate.nms_rotate(decode_boxes=per_class_decode_boxes, # scores=per_class_scores, # iou_threshold=self.fast_rcnn_nms_iou_threshold, # max_output_size=self.fast_rcnn_nms_max_boxes_per_class, # use_angle_condition=False, # angle_threshold=15, # use_gpu=cfgs.ROTATE_NMS_USE_GPU) # after_nms_boxes.append(tf.gather(per_class_decode_boxes, valid_indices)) # after_nms_scores.append(tf.gather(per_class_scores, valid_indices)) # after_nms_head_quadrant.append(tf.gather(per_head_quadrant, valid_indices)) # tmp_category = tf.gather(category, valid_indices) # category_list.append(tmp_category) # all_nms_boxes = tf.concat(after_nms_boxes, axis=0) # all_nms_scores = tf.concat(after_nms_scores, axis=0) # all_nms_head_quadrant = tf.concat(after_nms_head_quadrant, axis=0) # all_category = tf.concat(category_list, axis=0) ## all_nms_boxes = boxes_utils.clip_boxes_to_img_boundaries(all_nms_boxes, ## img_shape=self.img_shape) scores, _ = tf.nn.top_k( scores[:, 1:], 1) # select the max score in all classes as nms score scores = tf.squeeze(scores) valid_indices = nms_rotate.nms_rotate( decode_boxes=decode_boxes, scores=scores, iou_threshold=self.fast_rcnn_nms_iou_threshold, max_output_size=self.fast_rcnn_nms_max_boxes_per_class, use_angle_condition=False, angle_threshold=15, use_gpu=cfgs.ROTATE_NMS_USE_GPU) all_nms_boxes = tf.gather(decode_boxes, valid_indices) all_nms_scores = tf.gather(scores, valid_indices) all_nms_head_quadrant = tf.gather(head_quadrant, valid_indices) all_category = tf.gather(category, valid_indices) scores_large_than_threshold_indices = \ tf.reshape(tf.where(tf.greater(all_nms_scores, self.show_detections_score_threshold)), [-1]) all_nms_boxes = tf.gather(all_nms_boxes, scores_large_than_threshold_indices) all_nms_scores = tf.gather(all_nms_scores, scores_large_than_threshold_indices) all_nms_head_quadrant = tf.gather( all_nms_head_quadrant, scores_large_than_threshold_indices) all_category = tf.gather(all_category, scores_large_than_threshold_indices) return all_nms_boxes, all_nms_scores, all_nms_head_quadrant, tf.shape( all_nms_boxes)[0], all_category
def postprocess_detctions(rpn_bbox_pred, rpn_cls_prob, anchors, is_training, gpu_id): return_boxes_pred = [] return_scores = [] return_labels = [] for j in range(0, cfgs.CLASS_NUM): scores = rpn_cls_prob[:, j] if is_training: indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [ -1, ]) else: indices = tf.reshape( tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [ -1, ]) anchors_ = tf.gather(anchors, indices) rpn_bbox_pred_ = tf.gather(rpn_bbox_pred, indices) scores = tf.gather(scores, indices) if 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 * tf.ones_like(x_c) anchors_ = tf.transpose(tf.stack([x_c, y_c, w, h, theta])) if cfgs.ANGLE_RANGE == 180: anchors_ = tf.py_func(coordinate_present_convert, inp=[anchors_, -1], Tout=[tf.float32]) anchors_ = tf.reshape(anchors_, [-1, 5]) boxes_pred = bbox_transform.rbbox_transform_inv(boxes=anchors_, deltas=rpn_bbox_pred_) if cfgs.ANGLE_RANGE == 180: _, _, _, _, theta = tf.unstack(boxes_pred, axis=1) indx = tf.reshape( tf.where( tf.logical_and(tf.less(theta, 0), tf.greater_equal(theta, -180))), [ -1, ]) boxes_pred = tf.gather(boxes_pred, indx) scores = tf.gather(scores, indx) boxes_pred = tf.py_func(coordinate_present_convert, inp=[boxes_pred, 1], Tout=[tf.float32]) boxes_pred = tf.reshape(boxes_pred, [-1, 5]) max_output_size = 4000 if 'DOTA' in cfgs.NET_NAME else 200 nms_indices = nms_rotate.nms_rotate( decode_boxes=boxes_pred, scores=scores, iou_threshold=cfgs.NMS_IOU_THRESHOLD, max_output_size=100 if is_training else max_output_size, use_angle_condition=False, angle_threshold=15, use_gpu=True, gpu_id=gpu_id) tmp_boxes_pred = tf.reshape(tf.gather(boxes_pred, nms_indices), [-1, 5]) tmp_scores = tf.reshape(tf.gather(scores, nms_indices), [ -1, ]) return_boxes_pred.append(tmp_boxes_pred) return_scores.append(tmp_scores) return_labels.append(tf.ones_like(tmp_scores) * (j + 1)) return_boxes_pred = tf.concat(return_boxes_pred, axis=0) return_scores = tf.concat(return_scores, axis=0) return_labels = tf.concat(return_labels, axis=0) return return_boxes_pred, return_scores, return_labels