--- /dev/null
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import tensorflow as tf
+import numpy as np
+
+
+
+# def encode_boxes(ex_rois, gt_rois, scale_factor=None):
+# ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0
+# ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0
+# ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths
+# ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights
+#
+# gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0
+# gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0
+# gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths
+# gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights
+#
+# targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths
+# targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights
+# targets_dw = np.log(gt_widths / ex_widths)
+# targets_dh = np.log(gt_heights / ex_heights)
+#
+# if scale_factor:
+# targets_dx = targets_dx * scale_factor[0]
+# targets_dy = targets_dy * scale_factor[1]
+# targets_dw = targets_dw * scale_factor[2]
+# targets_dh = targets_dh * scale_factor[3]
+#
+# targets = np.vstack(
+# (targets_dx, targets_dy, targets_dw, targets_dh)).transpose()
+# return targets
+#
+#
+# def _concat_new_axis(t1, t2, t3, t4, axis):
+# return tf.concat(
+# [tf.expand_dims(t1, -1), tf.expand_dims(t2, -1),
+# tf.expand_dims(t3, -1), tf.expand_dims(t4, -1)], axis=axis)
+#
+#
+# def decode_boxes(boxes, deltas, scale_factor=None):
+# widths = boxes[:, 2] - boxes[:, 0] + 1.0
+# heights = boxes[:, 3] - boxes[:, 1] + 1.0
+# ctr_x = tf.expand_dims(boxes[:, 0] + 0.5 * widths, -1)
+# ctr_y = tf.expand_dims(boxes[:, 1] + 0.5 * heights, -1)
+#
+# dx = deltas[:, 0::4]
+# dy = deltas[:, 1::4]
+# dw = deltas[:, 2::4]
+# dh = deltas[:, 3::4]
+#
+# if scale_factor:
+# dx /= scale_factor[0]
+# dy /= scale_factor[1]
+# dw /= scale_factor[2]
+# dh /= scale_factor[3]
+#
+# widths = tf.expand_dims(widths, -1)
+# heights = tf.expand_dims(heights, -1)
+#
+# pred_ctr_x = dx * widths + ctr_x
+# pred_ctr_y = dy * heights + ctr_y
+# pred_w = tf.exp(dw) * widths
+# pred_h = tf.exp(dh) * heights
+#
+# # x1
+# # pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w
+# pred_x1 = pred_ctr_x - 0.5 * pred_w
+# # y1
+# # pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h
+# pred_y1 = pred_ctr_y - 0.5 * pred_h
+# # x2
+# # pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w
+# pred_x2 = pred_ctr_x + 0.5 * pred_w
+# # y2
+# # pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h
+# pred_y2 = pred_ctr_y + 0.5 * pred_h
+#
+# pred_boxes = _concat_new_axis(pred_x1, pred_y1, pred_x2, pred_y2, 2)
+# pred_boxes = tf.reshape(pred_boxes, (tf.shape(pred_boxes)[0], -1))
+# return pred_boxes
+
+
+def decode_boxes(encoded_boxes, reference_boxes, scale_factors=None):
+ '''
+
+ :param encoded_boxes:[N, 4]
+ :param reference_boxes: [N, 4] .
+ :param scale_factors: use for scale.
+
+ in the first stage, reference_boxes are anchors
+ in the second stage, reference boxes are proposals(decode) produced by first stage
+ :return:decode boxes [N, 4]
+ '''
+
+ t_xcenter, t_ycenter, t_w, t_h = tf.unstack(encoded_boxes, axis=1)
+ if scale_factors:
+ t_xcenter /= scale_factors[0]
+ t_ycenter /= scale_factors[1]
+ t_w /= scale_factors[2]
+ t_h /= scale_factors[3]
+
+ reference_xmin, reference_ymin, reference_xmax, reference_ymax = tf.unstack(reference_boxes, axis=1)
+ # reference boxes are anchors in the first stage
+
+ reference_xcenter = (reference_xmin + reference_xmax) / 2.
+ reference_ycenter = (reference_ymin + reference_ymax) / 2.
+ reference_w = reference_xmax - reference_xmin
+ reference_h = reference_ymax - reference_ymin
+
+ predict_xcenter = t_xcenter * reference_w + reference_xcenter
+ predict_ycenter = t_ycenter * reference_h + reference_ycenter
+ predict_w = tf.exp(t_w) * reference_w
+ predict_h = tf.exp(t_h) * reference_h
+
+ predict_xmin = predict_xcenter - predict_w / 2.
+ predict_xmax = predict_xcenter + predict_w / 2.
+ predict_ymin = predict_ycenter - predict_h / 2.
+ predict_ymax = predict_ycenter + predict_h / 2.
+
+ return tf.transpose(tf.stack([predict_xmin, predict_ymin,
+ predict_xmax, predict_ymax]))
+
+
+def encode_boxes(unencode_boxes, reference_boxes, scale_factors=None):
+ '''
+
+ :param unencode_boxes: [-1, 4]
+ :param reference_boxes: [-1, 4]
+ :return: encode_boxes [-1, 4]
+ '''
+
+ xmin, ymin, xmax, ymax = unencode_boxes[:, 0], unencode_boxes[:, 1], unencode_boxes[:, 2], unencode_boxes[:, 3]
+
+ reference_xmin, reference_ymin, reference_xmax, reference_ymax = reference_boxes[:, 0], reference_boxes[:, 1], \
+ reference_boxes[:, 2], reference_boxes[:, 3]
+
+ x_center = (xmin + xmax) / 2.
+ y_center = (ymin + ymax) / 2.
+ w = xmax - xmin + 1e-8
+ h = ymax - ymin + 1e-8
+
+ reference_xcenter = (reference_xmin + reference_xmax) / 2.
+ reference_ycenter = (reference_ymin + reference_ymax) / 2.
+ reference_w = reference_xmax - reference_xmin + 1e-8
+ reference_h = reference_ymax - reference_ymin + 1e-8
+
+ # w + 1e-8 to avoid NaN in division and log below
+
+ t_xcenter = (x_center - reference_xcenter) / reference_w
+ t_ycenter = (y_center - reference_ycenter) / reference_h
+ t_w = np.log(w/reference_w)
+ t_h = np.log(h/reference_h)
+
+ if scale_factors:
+ t_xcenter *= scale_factors[0]
+ t_ycenter *= scale_factors[1]
+ t_w *= scale_factors[2]
+ t_h *= scale_factors[3]
+
+ return np.transpose(np.stack([t_xcenter, t_ycenter, t_w, t_h], axis=0))
Code Review / ealt-edge.git / blobdiff