+++ /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