X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=example-apps%2FPDD%2Fpcb-defect-detection%2Flibs%2Fbox_utils%2Fencode_and_decode.py;fp=example-apps%2FPDD%2Fpcb-defect-detection%2Flibs%2Fbox_utils%2Fencode_and_decode.py;h=66092b20b9130d79a740930cfb4d8b7293e28b1f;hb=a785567fb9acfc68536767d20f60ba917ae85aa1;hp=0000000000000000000000000000000000000000;hpb=94a133e696b9b2a7f73544462c2714986fa7ab4a;p=ealt-edge.git diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py new file mode 100755 index 0000000..66092b2 --- /dev/null +++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py @@ -0,0 +1,165 @@ +# -*- 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))