人脸检测（二）

古城微笑少年丶 2022-06-16 05:36 382阅读 0赞

2.级联CNN人脸检测方法
采用级联网络来进行人脸检测，参考2015年CVPR上的一篇论文A Convolution Neural Network Cascade for Face Detection，它采用了12-net，24-net，48-net级联网络用于人脸检测，12-calibration-net，24-calibration，48-calibration边界校订网络用于更好的定位人脸框。它最小能够检测12x12大小的人脸，相比于单个CNN的人脸检测方法，大大加快了人脸检测的速度，并提高了人脸框的准确度，人脸检测的准确率和召回率也很高，在FDDB数据集上达到了当时最高的分数。

这里写图片描述

论文下载地址
github开源代码
github开源模型

作者的代码写的非常优美易懂，注释简洁明了，其级联CNN人脸检测的基本思路如下：
这里写图片描述
（1）12-net：首先用一个输入为12 x 12图像的小网络来训练人脸非人脸二分类器，将最后的全连接层修改成卷积层，这样的全卷积网络即12-full-conv-net就可以接受任意大小的输入图像，输出的特征图表示对应感受野区域属于人脸的概率。在检测时，假设要检测的最小人连尺寸为K x K，例如40 x 40，将待检测的图像缩放到原来的12/K，然后将整幅图像输入到训练好的12 x 12的全卷积网络，得到特征图，设定阈值过滤掉得分低的，这样就可以去除绝大部分不感兴趣区域，保留一定数量的候选框。
（2）12-calibration-net：训练一个输入为12 x 12图像的校订网络，来矫正上一步12-net得到的人脸框边界，它实质上是一个45类分类器，判断当前图像中包含的人脸是左右偏了、上下偏了还是大了小了，即包括：
x方向上-0.17、0、0.17共3种平移
y方向上-0.17、0、0.17共3三种平移
以及0.83、0.91、1.0、1.1、1.21共5种缩放尺度
检测时，将上一步12-net得到的所有人脸候选框作为12-calibration-net的输入，根据其分类结果对候选框位置进行校订。
（3）localNMS：对上述12-calibration-net矫正后的人脸候选框做局部非极大值抑制，过滤掉其中重叠的得分较低的候选框，保留得分更高的人脸候选框。
这里写图片描述
（4）24-net：训练输入为24 x 24图像的人脸分类器网络。测试时，以上一步localNMS得到的人脸候选框缩放到24 x 24大小，作为24-net网络输入，判定是否属于人脸，设置阈值保留得分较高的候选框。
（5）24-calibration-net：同样训练一个输入图像为24 x 24大小的边界校订分类网络，来矫正上一步24-net保留的人脸候选框的位置，候选框区域图像缩放到24 x 24大小，其它与12-calibration-net一致。
（6）localNMS：将24-calibration-net矫正后的人脸候选框进行局部非极大值抑制，过滤掉重叠的得分较低的候选框，保留得分更高的。
这里写图片描述
（7）48-net：训练一个更加准确的输入为48 x 48的人脸非人脸分类器。测试时，将上一步localNMS得到的人脸候选框缩放到48 x 48大小，作为48-net输入，保留得分高的人脸候选框。
（8）globalNMS：将48-net得到的所有人脸候选框进行全局非极大值抑制，保留所有的最佳人脸框
（9）48-calibration-net：训练一个输入为48 x 48的边界校订分类网络。测试时，将globalNMS得到的最佳人脸框缩放到48 x 48作为输入进行人脸框边界校订。

因此，我们需要先单独训练人脸非人脸二分类12-net，24-net，48-net网络，以及人脸框边界校订12-calibration-net，24-calibration，48-calibration网络。测试时，用图像金字塔来做多尺度人脸检测，对于任意的输入图像，依次经过12-net(12-full-conv-net) -> 12-calibration-net -> localNMS -> 24-net -> 24-calibration-net -> localNMS -> 48-net -> globalNMS -> 48-calibration-net，得到最终的人脸框作为检测结果。
其中localNMS和globalNMS(Non-maximum Suppression,NMS,非极大值抑制)的区别主要在于前者仅使用了IoU(Intersection over Union)，即交集与并集的比值，而后者还用到了IoM(Intersection over Min-area)，即交集与两者中最小面积的比值，来过滤重叠的候选框。
博主没有自己训练，而是直接用了作者训练好的模型。使用CNN_face_detection-master\face_detection文件夹下的face_cascade_fullconv_single_crop_single_image.py脚本可以对但张图像进行测试，代码如下，其中需要注意的是，我们可以根据需求来设置检测最小的人脸尺寸min_face_size，它与检测速度直接相关，如果我们需要检测的人脸比较大，例如在128x128以上时，检测可以达到实时水平。

  1. import numpy as np
  2. import cv2
  3. import time
  4. import os
  5. #from operator import itemgetter
  6. from load_model_functions import *
  7. from face_detection_functions import *
  9. # ==================  caffe  ======================================
  10. #caffe_root = '/home/anson/caffe-master/'  # this file is expected to be in {caffe_root}/examples
  11. import sys
  12. #sys.path.insert(0, caffe_root + 'python')
  13. import caffe
  14. # ==================  load models  ======================================
  15. net_12c_full_conv, net_12_cal, net_24c, net_24_cal, net_48c, net_48_cal = \
  16.     load_face_models(loadNet=True)
  18. nets = (net_12c_full_conv, net_12_cal, net_24c, net_24_cal, net_48c, net_48_cal)
  20. start_time = time.time()
  22. read_img_name = 'C:/Users/Administrator/Desktop/caffe/matlab/demo/1.jpg'
  23. img = cv2.imread(read_img_name)     # BGR
  25. print img.shape
  27. min_face_size = 48 #最小的人脸检测尺寸，设置的越小能检测到更小人脸的同时，速度下降的很快
  28. stride = 5 #步长，实际并未使用
  30. # caffe_image = np.true_divide(img, 255)      # convert to caffe style (0~1 BGR)
  31. # caffe_image = caffe_image[:, :, (2, 1, 0)]
  32. img_forward = np.array(img, dtype=np.float32)
  33. img_forward -= np.array((104, 117, 123))
  35. rectangles = detect_faces_net(nets, img_forward, min_face_size, stride, True, 2, 0.05)
  36. for rectangle in rectangles:    # draw rectangles
  37.         cv2.rectangle(img, (rectangle[0], rectangle[1]), (rectangle[2], rectangle[3]), (255, 0, 0), 2)
  39. end_time = time.time()
  40. print 'aver_time = ',(end_time-start_time)*1000,'ms'
  42. cv2.imshow('test img', img)
  43. cv2.waitKey(0)
  44. cv2.destroyAllWindows()

上述脚本文件中的detect_faces_net()函数在CNN_face_detection-master\face_detection文件夹下的face_detection_functions.py脚本中实现，face_detection_functions.py是整个级联网络的检测过程脚本，写的非常优雅，思路和注释清晰，本人针对自己需求进行了修改，代码如下：

  1. import numpy as np
  2. import cv2
  3. import time
  4. from operator import itemgetter
  5. # ==================  caffe  ======================================
  6. #caffe_root = '/home/anson/caffe-master/'  # this file is expected to be in {caffe_root}/examples
  7. import sys
  8. #sys.path.insert(0, caffe_root + 'python')
  9. import caffe
  11. def find_initial_scale(net_kind, min_face_size):
  12.     '''
  13.     :param net_kind: what kind of net (12, 24, or 48)
  14.     :param min_face_size: minimum face size
  15.     :return:    returns scale factor
  16.     '''
  17.     return float(min_face_size) / net_kind
  18. def resize_image(img, scale):
  19.     '''
  20.     :param img: original img
  21.     :param scale: scale factor
  22.     :return:    resized image
  23.     '''
  24.     height, width, channels = img.shape
  25.     new_height = int(height / scale)     # resized new height
  26.     new_width = int(width / scale)       # resized new width
  27.     new_dim = (new_width, new_height)
  28.     img_resized = cv2.resize(img, new_dim)      # resized image
  29.     return img_resized
  30. def draw_rectangle(net_kind, img, face):
  31.     '''
  32.     :param net_kind: what kind of net (12, 24, or 48)
  33.     :param img: image to draw on
  34.     :param face: # list of info. in format [x, y, scale]
  35.     :return:    nothing
  36.     '''
  37.     x = face[0]
  38.     y = face[1]
  39.     scale = face[2]
  40.     original_x = int(x * scale)      # corresponding x and y at original image
  41.     original_y = int(y * scale)
  42.     original_x_br = int(x * scale + net_kind * scale)    # bottom right x and y
  43.     original_y_br = int(y * scale + net_kind * scale)
  44.     cv2.rectangle(img, (original_x, original_y), (original_x_br, original_y_br), (255,0,0), 2)
  45. def IoU(rect_1, rect_2):
  46.     '''
  47.     :param rect_1: list in format [x11, y11, x12, y12, confidence, current_scale]
  48.     :param rect_2:  list in format [x21, y21, x22, y22, confidence, current_scale]
  49.     :return:    returns IoU ratio (intersection over union) of two rectangles
  50.     '''
  51.     x11 = rect_1[0]    # first rectangle top left x
  52.     y11 = rect_1[1]    # first rectangle top left y
  53.     x12 = rect_1[2]    # first rectangle bottom right x
  54.     y12 = rect_1[3]    # first rectangle bottom right y
  55.     x21 = rect_2[0]    # second rectangle top left x
  56.     y21 = rect_2[1]    # second rectangle top left y
  57.     x22 = rect_2[2]    # second rectangle bottom right x
  58.     y22 = rect_2[3]    # second rectangle bottom right y
  59.     x_overlap = max(0, min(x12,x22) -max(x11,x21))
  60.     y_overlap = max(0, min(y12,y22) -max(y11,y21))
  61.     intersection = x_overlap * y_overlap
  62.     union = (x12-x11) * (y12-y11) + (x22-x21) * (y22-y21) - intersection
  63.     return float(intersection) / union
  64. def IoM(rect_1, rect_2):
  65.     '''
  66.     :param rect_1: list in format [x11, y11, x12, y12, confidence, current_scale]
  67.     :param rect_2:  list in format [x21, y21, x22, y22, confidence, current_scale]
  68.     :return:    returns IoM ratio (intersection over min-area) of two rectangles
  69.     '''
  70.     x11 = rect_1[0]    # first rectangle top left x
  71.     y11 = rect_1[1]    # first rectangle top left y
  72.     x12 = rect_1[2]    # first rectangle bottom right x
  73.     y12 = rect_1[3]    # first rectangle bottom right y
  74.     x21 = rect_2[0]    # second rectangle top left x
  75.     y21 = rect_2[1]    # second rectangle top left y
  76.     x22 = rect_2[2]    # second rectangle bottom right x
  77.     y22 = rect_2[3]    # second rectangle bottom right y
  78.     x_overlap = max(0, min(x12,x22) -max(x11,x21))
  79.     y_overlap = max(0, min(y12,y22) -max(y11,y21))
  80.     intersection = x_overlap * y_overlap
  81.     rect1_area = (y12 - y11) * (x12 - x11)
  82.     rect2_area = (y22 - y21) * (x22 - x21)
  83.     min_area = min(rect1_area, rect2_area)
  84.     return float(intersection) / min_area
  85. def localNMS(rectangles):
  86.     '''
  87.     :param rectangles:  list of rectangles, which are lists in format [x11, y11, x12, y12, confidence, current_scale],
  88.                         sorted from highest confidence to smallest
  89.     :return:    list of rectangles after local NMS
  90.     '''
  91.     result_rectangles = rectangles[:]  # list to return
  92.     number_of_rects = len(result_rectangles)
  93.     threshold = 0.3     # threshold of IoU of two rectangles
  94.     cur_rect = 0
  95.     while cur_rect < number_of_rects - 1:     # start from first element to second last element
  96.         rects_to_compare = number_of_rects - cur_rect - 1      # elements after current element to compare
  97.         cur_rect_to_compare = cur_rect + 1    # start comparing with element after current
  98.         while rects_to_compare > 0:      # while there is at least one element after current to compare
  99.             if (IoU(result_rectangles[cur_rect], result_rectangles[cur_rect_to_compare]) >= threshold) \
  100.                     and (result_rectangles[cur_rect][5] == result_rectangles[cur_rect_to_compare][5]):  # scale is same
  102.                 del result_rectangles[cur_rect_to_compare]      # delete the rectangle
  103.                 number_of_rects -= 1
  104.             else:
  105.                 cur_rect_to_compare += 1    # skip to next rectangle
  106.             rects_to_compare -= 1
  107.         cur_rect += 1   # finished comparing for current rectangle
  109.     return result_rectangles
  110. def globalNMS(rectangles):
  111.     '''
  112.     :param rectangles:  list of rectangles, which are lists in format [x11, y11, x12, y12, confidence, current_scale],
  113.                         sorted from highest confidence to smallest
  114.     :return:    list of rectangles after global NMS
  115.     '''
  116.     result_rectangles = rectangles[:]  # list to return
  117.     number_of_rects = len(result_rectangles)
  118.     threshold = 0.3     # threshold of IoU of two rectangles
  119.     cur_rect = 0
  120.     while cur_rect < number_of_rects - 1:     # start from first element to second last element
  121.         rects_to_compare = number_of_rects - cur_rect - 1      # elements after current element to compare
  122.         cur_rect_to_compare = cur_rect + 1    # start comparing with element ater current
  123.         while rects_to_compare > 0:      # while there is at least one element after current to compare
  124.             if IoU(result_rectangles[cur_rect], result_rectangles[cur_rect_to_compare]) >= 0.2  \
  125.                     or ((IoM(result_rectangles[cur_rect], result_rectangles[cur_rect_to_compare]) >= threshold)):
  126.                         #and (result_rectangles[cur_rect_to_compare][5] < 0.85)):  # if IoU ratio is higher than threshold #10/12=0.8333?
  127.                 del result_rectangles[cur_rect_to_compare]      # delete the rectangle
  128.                 number_of_rects -= 1
  129.             else:
  130.                 cur_rect_to_compare += 1    # skip to next rectangle
  131.             rects_to_compare -= 1
  132.         cur_rect += 1   # finished comparing for current rectangle
  134.     return result_rectangles
  136. # ====== Below functions (12cal ~ 48cal) take images in style of caffe (0~1 BGR)===
  137. def detect_face_12c(net_12c_full_conv, img, min_face_size, stride,
  138.                     multiScale=False, scale_factor=1.414, threshold=0.05):
  139.     '''
  140.     :param img: image to detect faces
  141.     :param min_face_size: minimum face size to detect (in pixels)
  142.     :param stride: stride (in pixels)
  143.     :param multiScale: whether to find faces under multiple scales or not
  144.     :param scale_factor: scale to apply for pyramid
  145.     :param threshold: score of patch must be above this value to pass to next net
  146.     :return:    list of rectangles after global NMS
  147.     '''
  148.     net_kind = 12
  149.     rectangles = []   # list of rectangles [x11, y11, x12, y12, confidence, current_scale] (corresponding to original image)
  151.     current_scale = find_initial_scale(net_kind, min_face_size)     # find initial scale
  152.     caffe_img_resized = resize_image(img, current_scale)      # resized initial caffe image
  153.     current_height, current_width, channels = caffe_img_resized.shape
  155.     while current_height > net_kind and current_width > net_kind:
  156.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))  # switch from H x W x C to C x H x W
  157.         # shape for input (data blob is N x C x H x W), set data
  158.         net_12c_full_conv.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  159.         net_12c_full_conv.blobs['data'].data[...] = caffe_img_resized_CHW
  160.         # run net and take argmax for prediction
  161.         net_12c_full_conv.forward()
  162.         out = net_12c_full_conv.blobs['prob'].data[0][1, :, :]
  163.         # print out.shape
  164.         out_height, out_width = out.shape
  166.         for current_y in range(0, out_height):
  167.             for current_x in range(0, out_width):
  168.                 # total_windows += 1
  169.                 confidence = out[current_y, current_x]  # left index is y, right index is x (starting from 0)
  170.                 if confidence >= threshold:
  171.                     current_rectangle = [int(2*current_x*current_scale), int(2*current_y*current_scale),
  172.                                              int(2*current_x*current_scale + net_kind*current_scale),
  173.                                              int(2*current_y*current_scale + net_kind*current_scale),
  174.                                              confidence, current_scale]     # find corresponding patch on image
  175.                     rectangles.append(current_rectangle)
  176.         if multiScale is False:
  177.             break
  178.         else:
  179.             caffe_img_resized = resize_image(caffe_img_resized, scale_factor)
  180.             current_scale *= scale_factor
  181.             current_height, current_width, channels = caffe_img_resized.shape
  183.     return rectangles
  184. def cal_face_12c(net_12_cal, caffe_img, rectangles):
  185.     '''
  186.     :param caffe_image: image in caffe style to detect faces
  187.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  188.     :return:    rectangles after calibration
  189.     '''
  190.     height, width, channels = caffe_img.shape
  191.     result = []
  192.     all_cropped_caffe_img = []
  194.     for cur_rectangle in rectangles:
  196.         original_x1 = cur_rectangle[0]
  197.         original_y1 = cur_rectangle[1]
  198.         original_x2 = cur_rectangle[2]
  199.         original_y2 = cur_rectangle[3]
  201.         cropped_caffe_img = caffe_img[original_y1:original_y2, original_x1:original_x2] # crop image
  202.         all_cropped_caffe_img.append(cropped_caffe_img)
  204.     if len(all_cropped_caffe_img) == 0:
  205.         return []
  207.     output_all = net_12_cal.predict(all_cropped_caffe_img)   # predict through caffe
  209.     for cur_rect in range(len(rectangles)):
  210.         cur_rectangle = rectangles[cur_rect]
  211.         output = output_all[cur_rect]
  212.         prediction = output[0]      # (44, 1) ndarray
  214.         threshold = 0.1
  215.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  217.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  219.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  220.             result.append(cur_rectangle)
  221.             continue
  223.         original_x1 = cur_rectangle[0]
  224.         original_y1 = cur_rectangle[1]
  225.         original_x2 = cur_rectangle[2]
  226.         original_y2 = cur_rectangle[3]
  227.         original_w = original_x2 - original_x1
  228.         original_h = original_y2 - original_y1
  230.         total_s_change = 0
  231.         total_x_change = 0
  232.         total_y_change = 0
  234.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  235.             cal_label = int(indices[current_cal])   # should be number in 0~44
  236.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  237.                 total_s_change += 0.83
  238.             elif (cal_label >= 9) and (cal_label <= 17):
  239.                 total_s_change += 0.91
  240.             elif (cal_label >= 18) and (cal_label <= 26):
  241.                 total_s_change += 1.0
  242.             elif (cal_label >= 27) and (cal_label <= 35):
  243.                 total_s_change += 1.10
  244.             else:
  245.                 total_s_change += 1.21
  247.             if cal_label % 9 <= 2:       # decide x change
  248.                 total_x_change += -0.17
  249.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  250.                 total_x_change += 0.17
  252.             if cal_label % 3 == 0:       # decide y change
  253.                 total_y_change += -0.17
  254.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  255.                 total_y_change += 0.17
  257.         s_change = total_s_change / number_of_cals      # calculate average
  258.         x_change = total_x_change / number_of_cals
  259.         y_change = total_y_change / number_of_cals
  261.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  262.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  263.         cur_result[1] = int(max(0, original_y1 - original_h * y_change / s_change))
  264.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  265.         cur_result[3] = int(min(height, cur_result[1] + original_h / s_change))
  267.         result.append(cur_result)
  269.     result = sorted(result, key=itemgetter(4), reverse=True)    # sort rectangles according to confidence
  270.                                                                         # reverse, so that it ranks from large to small
  271.     return result
  272. def detect_face_24c(net_24c, caffe_img, rectangles):
  273.     '''
  274.     :param caffe_img: image in caffe style to detect faces
  275.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  276.     :return:    rectangles after calibration
  277.     '''
  278.     result = []
  279.     all_cropped_caffe_img = []
  281.     for cur_rectangle in rectangles:
  283.         x1 = cur_rectangle[0]
  284.         y1 = cur_rectangle[1]
  285.         x2 = cur_rectangle[2]
  286.         y2 = cur_rectangle[3]
  288.         cropped_caffe_img = caffe_img[y1:y2, x1:x2]     # crop image
  289.         all_cropped_caffe_img.append(cropped_caffe_img)
  291.     if len(all_cropped_caffe_img) == 0:
  292.         return []
  294.     prediction_all = net_24c.predict(all_cropped_caffe_img)   # predict through caffe
  296.     for cur_rect in range(len(rectangles)):
  297.         confidence = prediction_all[cur_rect][1]
  298.         if confidence > 0.05:
  299.             cur_rectangle = rectangles[cur_rect]
  300.             cur_rectangle[4] = confidence
  301.             result.append(cur_rectangle)
  303.     return result
  304. def cal_face_24c(net_24_cal, caffe_img, rectangles):
  305.     '''
  306.     :param caffe_image: image in caffe style to detect faces
  307.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  308.     :return:    rectangles after calibration
  309.     '''
  310.     height, width, channels = caffe_img.shape
  311.     result = []
  313.     for cur_rectangle in rectangles:
  315.         original_x1 = cur_rectangle[0]
  316.         original_y1 = cur_rectangle[1]
  317.         original_x2 = cur_rectangle[2]
  318.         original_y2 = cur_rectangle[3]
  319.         original_w = original_x2 - original_x1
  320.         original_h = original_y2 - original_y1
  322.         cropped_caffe_img = caffe_img[original_y1:original_y2, original_x1:original_x2] # crop image
  323.         output = net_24_cal.predict([cropped_caffe_img])   # predict through caffe
  324.         prediction = output[0]      # (44, 1) ndarray
  326.         threshold = 0.1
  327.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  329.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  331.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  332.             result.append(cur_rectangle)
  333.             continue
  335.         total_s_change = 0
  336.         total_x_change = 0
  337.         total_y_change = 0
  339.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  340.             cal_label = int(indices[current_cal])   # should be number in 0~44
  341.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  342.                 total_s_change += 0.83
  343.             elif (cal_label >= 9) and (cal_label <= 17):
  344.                 total_s_change += 0.91
  345.             elif (cal_label >= 18) and (cal_label <= 26):
  346.                 total_s_change += 1.0
  347.             elif (cal_label >= 27) and (cal_label <= 35):
  348.                 total_s_change += 1.10
  349.             else:
  350.                 total_s_change += 1.21
  352.             if cal_label % 9 <= 2:       # decide x change
  353.                 total_x_change += -0.17
  354.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  355.                 total_x_change += 0.17
  357.             if cal_label % 3 == 0:       # decide y change
  358.                 total_y_change += -0.17
  359.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  360.                 total_y_change += 0.17
  362.         s_change = total_s_change / number_of_cals      # calculate average
  363.         x_change = total_x_change / number_of_cals
  364.         y_change = total_y_change / number_of_cals
  366.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  367.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  368.         cur_result[1] = int(max(0, original_y1 - original_h * y_change / s_change))
  369.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  370.         cur_result[3] = int(min(height, cur_result[1] + original_h / s_change))
  372.         result.append(cur_result)
  374.     return result
  375. def detect_face_48c(net_48c, caffe_img, rectangles):
  376.     '''
  377.     :param caffe_img: image in caffe style to detect faces
  378.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  379.     :return:    rectangles after calibration
  380.     '''
  381.     result = []
  382.     all_cropped_caffe_img = []
  384.     for cur_rectangle in rectangles:
  386.         x1 = cur_rectangle[0]
  387.         y1 = cur_rectangle[1]
  388.         x2 = cur_rectangle[2]
  389.         y2 = cur_rectangle[3]
  391.         cropped_caffe_img = caffe_img[y1:y2, x1:x2]     # crop image
  392.         all_cropped_caffe_img.append(cropped_caffe_img)
  394.         prediction = net_48c.predict([cropped_caffe_img])   # predict through caffe
  395.         confidence = prediction[0][1]
  397.         if confidence > 0.3:
  398.             cur_rectangle[4] = confidence
  399.             result.append(cur_rectangle)
  401.     result = sorted(result, key=itemgetter(4), reverse=True)    # sort rectangles according to confidence
  402.                                                                         # reverse, so that it ranks from large to small
  403.     return result
  404. def cal_face_48c(net_48_cal, caffe_img, rectangles):
  405.     '''
  406.     :param caffe_image: image in caffe style to detect faces
  407.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  408.     :return:    rectangles after calibration
  409.     '''
  410.     height, width, channels = caffe_img.shape
  411.     result = []
  412.     for cur_rectangle in rectangles:
  414.         original_x1 = cur_rectangle[0]
  415.         original_y1 = cur_rectangle[1]
  416.         original_x2 = cur_rectangle[2]
  417.         original_y2 = cur_rectangle[3]
  418.         original_w = original_x2 - original_x1
  419.         original_h = original_y2 - original_y1
  421.         cropped_caffe_img = caffe_img[original_y1:original_y2, original_x1:original_x2] # crop image
  422.         output = net_48_cal.predict([cropped_caffe_img])   # predict through caffe
  424.         prediction = output[0]      # (44, 1) ndarray
  426.         threshold = 0.1
  427.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  429.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  431.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  432.             result.append(cur_rectangle)
  433.             continue
  435.         total_s_change = 0
  436.         total_x_change = 0
  437.         total_y_change = 0
  439.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  440.             cal_label = int(indices[current_cal])   # should be number in 0~44
  441.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  442.                 total_s_change += 0.83
  443.             elif (cal_label >= 9) and (cal_label <= 17):
  444.                 total_s_change += 0.91
  445.             elif (cal_label >= 18) and (cal_label <= 26):
  446.                 total_s_change += 1.0
  447.             elif (cal_label >= 27) and (cal_label <= 35):
  448.                 total_s_change += 1.10
  449.             else:
  450.                 total_s_change += 1.21
  452.             if cal_label % 9 <= 2:       # decide x change
  453.                 total_x_change += -0.17
  454.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  455.                 total_x_change += 0.17
  457.             if cal_label % 3 == 0:       # decide y change
  458.                 total_y_change += -0.17
  459.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  460.                 total_y_change += 0.17
  462.         s_change = total_s_change / number_of_cals      # calculate average
  463.         x_change = total_x_change / number_of_cals
  464.         y_change = total_y_change / number_of_cals
  466.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  467.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  468.         cur_result[1] = int(max(0, original_y1 - 1.1 * original_h * y_change / s_change))
  469.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  470.         cur_result[3] = int(min(height, cur_result[1] + 1.1 * original_h / s_change))
  472.         result.append(cur_result)
  474.     return result
  476. def detect_faces(nets, img_forward, caffe_image, min_face_size, stride,
  477.                  multiScale=False, scale_factor=1.414, threshold=0.05):
  478.     '''
  479.     Complete flow of face cascade detection
  480.     :param nets: 6 nets as a tuple
  481.     :param img_forward: image in normal style after subtracting mean pixel value
  482.     :param caffe_image: image in style of caffe (0~1 BGR)
  483.     :param min_face_size:
  484.     :param stride:
  485.     :param multiScale:
  486.     :param scale_factor:
  487.     :param threshold:
  488.     :return: list of rectangles
  489.     '''
  490.     net_12c_full_conv = nets[0]
  491.     net_12_cal = nets[1]
  492.     net_24c = nets[2]
  493.     net_24_cal = nets[3]
  494.     net_48c = nets[4]
  495.     net_48_cal = nets[5]
  497.     rectangles = detect_face_12c(net_12c_full_conv, img_forward, min_face_size,
  498.                                  stride, multiScale, scale_factor, threshold)     # detect faces
  499.     rectangles = cal_face_12c(net_12_cal, caffe_image, rectangles)      # calibration
  500.     rectangles = localNMS(rectangles)      # apply local NMS
  501.     rectangles = detect_face_24c(net_24c, caffe_image, rectangles)
  502.     rectangles = cal_face_24c(net_24_cal, caffe_image, rectangles)      # calibration
  503.     rectangles = localNMS(rectangles)      # apply local NMS
  504.     rectangles = detect_face_48c(net_48c, caffe_image, rectangles)
  505.     rectangles = globalNMS(rectangles)      # apply global NMS
  506.     rectangles = cal_face_48c(net_48_cal, caffe_image, rectangles)      # calibration
  508.     return rectangles
  510. # ========== Adjusts net to take one crop of image only during test time ==========
  511. # ====== Below functions take images in normal style after subtracting mean pixel value===
  512. def detect_face_12c_net(net_12c_full_conv, img_forward, min_face_size, stride,
  513.                     multiScale=False, scale_factor=1.414, threshold=0.05):
  514.     '''
  515.     Adjusts net to take one crop of image only during test time
  516.     :param img: image in caffe style to detect faces
  517.     :param min_face_size: minimum face size to detect (in pixels)
  518.     :param stride: stride (in pixels)
  519.     :param multiScale: whether to find faces under multiple scales or not
  520.     :param scale_factor: scale to apply for pyramid
  521.     :param threshold: score of patch must be above this value to pass to next net
  522.     :return:    list of rectangles after global NMS
  523.     '''
  524.     net_kind = 12
  525.     rectangles = []   # list of rectangles [x11, y11, x12, y12, confidence, current_scale] (corresponding to original image)
  527.     current_scale = find_initial_scale(net_kind, min_face_size)     # find initial scale
  528.     caffe_img_resized = resize_image(img_forward, current_scale)      # resized initial caffe image
  529.     current_height, current_width, channels = caffe_img_resized.shape
  531.     # print "Shape after resizing : " + str(caffe_img_resized.shape)
  533.     while current_height > net_kind and current_width > net_kind:
  534.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))  # switch from H x W x C to C x H x W
  535.         # shape for input (data blob is N x C x H x W), set data
  536.         net_12c_full_conv.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  537.         net_12c_full_conv.blobs['data'].data[...] = caffe_img_resized_CHW
  538.         # run net and take argmax for prediction
  539.         net_12c_full_conv.forward()
  541.         out = net_12c_full_conv.blobs['prob'].data[0][1, :, :]
  542.         # print out.shape
  543.         out_height, out_width = out.shape
  545.         # threshold = 0.02
  546.         # idx = out[:, :] >= threshold
  547.         # out[idx] = 1
  548.         # idx = out[:, :] < threshold
  549.         # out[idx] = 0
  550.         # cv2.imshow('img', out*255)
  551.         # cv2.waitKey(0)
  553.         # print "Shape of output after resizing " + str(caffe_img_resized.shape) + " : " + str(out.shape)
  555.         for current_y in range(0, out_height):
  556.             for current_x in range(0, out_width):
  557.                 # total_windows += 1
  558.                 confidence = out[current_y, current_x]  # left index is y, right index is x (starting from 0)
  559.                 if confidence >= threshold:
  560.                     current_rectangle = [int(2*current_x*current_scale), int(2*current_y*current_scale),
  561.                                              int(2*current_x*current_scale + net_kind*current_scale),
  562.                                              int(2*current_y*current_scale + net_kind*current_scale),
  563.                                              confidence, current_scale]     # find corresponding patch on image
  564.                     rectangles.append(current_rectangle)
  565.         if multiScale is False:
  566.             break
  567.         else:
  568.             caffe_img_resized = resize_image(caffe_img_resized, scale_factor)
  569.             current_scale *= scale_factor
  570.             current_height, current_width, channels = caffe_img_resized.shape
  572.     return rectangles
  573. def cal_face_12c_net(net_12_cal, img_forward, rectangles):
  574.     '''
  575.     Adjusts net to take one crop of image only during test time
  576.     :param caffe_image: image in caffe style to detect faces
  577.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  578.     :return:    rectangles after calibration
  579.     '''
  581.     height, width, channels = img_forward.shape
  582.     result = []
  583.     for cur_rectangle in rectangles:
  585.         original_x1 = cur_rectangle[0]
  586.         original_y1 = cur_rectangle[1]
  587.         original_x2 = cur_rectangle[2]
  588.         original_y2 = cur_rectangle[3]
  589.         original_w = original_x2 - original_x1
  590.         original_h = original_y2 - original_y1
  592.         cropped_caffe_img = img_forward[original_y1:original_y2, original_x1:original_x2] # crop image
  594.         caffe_img_resized = cv2.resize(cropped_caffe_img, (12, 12))
  595.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))
  596.         net_12_cal.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  597.         net_12_cal.blobs['data'].data[...] = caffe_img_resized_CHW
  598.         net_12_cal.forward()
  600.         output = net_12_cal.blobs['prob'].data
  602.         # output = net_12_cal.predict([cropped_caffe_img])   # predict through caffe
  604.         prediction = output[0]      # (44, 1) ndarray
  606.         threshold = 0.1
  607.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  609.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  611.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  612.             result.append(cur_rectangle)
  613.             continue
  615.         total_s_change = 0
  616.         total_x_change = 0
  617.         total_y_change = 0
  619.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  620.             cal_label = int(indices[current_cal])   # should be number in 0~44
  621.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  622.                 total_s_change += 0.83
  623.             elif (cal_label >= 9) and (cal_label <= 17):
  624.                 total_s_change += 0.91
  625.             elif (cal_label >= 18) and (cal_label <= 26):
  626.                 total_s_change += 1.0
  627.             elif (cal_label >= 27) and (cal_label <= 35):
  628.                 total_s_change += 1.10
  629.             else:
  630.                 total_s_change += 1.21
  632.             if cal_label % 9 <= 2:       # decide x change
  633.                 total_x_change += -0.17
  634.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  635.                 total_x_change += 0.17
  637.             if cal_label % 3 == 0:       # decide y change
  638.                 total_y_change += -0.17
  639.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  640.                 total_y_change += 0.17
  642.         s_change = total_s_change / number_of_cals      # calculate average
  643.         x_change = total_x_change / number_of_cals
  644.         y_change = total_y_change / number_of_cals
  646.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  647.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  648.         cur_result[1] = int(max(0, original_y1 - original_h * y_change / s_change))
  649.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  650.         cur_result[3] = int(min(height, cur_result[1] + original_h / s_change))
  652.         result.append(cur_result)
  654.     result = sorted(result, key=itemgetter(4), reverse=True)    # sort rectangles according to confidence
  655.                                                                         # reverse, so that it ranks from large to small
  656.     return result
  657. def detect_face_24c_net(net_24c, img_forward, rectangles):
  658.     '''
  659.     Adjusts net to take one crop of image only during test time
  660.     :param caffe_img: image in caffe style to detect faces
  661.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  662.     :return:    rectangles after calibration
  663.     '''
  664.     result = []
  665.     for cur_rectangle in rectangles:
  667.         x1 = cur_rectangle[0]
  668.         y1 = cur_rectangle[1]
  669.         x2 = cur_rectangle[2]
  670.         y2 = cur_rectangle[3]
  672.         cropped_caffe_img = img_forward[y1:y2, x1:x2]     # crop image
  674.         caffe_img_resized = cv2.resize(cropped_caffe_img, (24, 24))
  675.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))
  676.         net_24c.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  677.         net_24c.blobs['data'].data[...] = caffe_img_resized_CHW
  678.         net_24c.forward()
  680.         prediction = net_24c.blobs['prob'].data
  682.         confidence = prediction[0][1]
  684.         if confidence > 0.9:#0.05:
  685.             cur_rectangle[4] = confidence
  686.             result.append(cur_rectangle)
  688.     return result
  689. def cal_face_24c_net(net_24_cal, img_forward, rectangles):
  690.     '''
  691.     Adjusts net to take one crop of image only during test time
  692.     :param caffe_image: image in caffe style to detect faces
  693.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  694.     :return:    rectangles after calibration
  695.     '''
  696.     height, width, channels = img_forward.shape
  697.     result = []
  698.     for cur_rectangle in rectangles:
  700.         original_x1 = cur_rectangle[0]
  701.         original_y1 = cur_rectangle[1]
  702.         original_x2 = cur_rectangle[2]
  703.         original_y2 = cur_rectangle[3]
  704.         original_w = original_x2 - original_x1
  705.         original_h = original_y2 - original_y1
  707.         cropped_caffe_img = img_forward[original_y1:original_y2, original_x1:original_x2] # crop image
  709.         caffe_img_resized = cv2.resize(cropped_caffe_img, (24, 24))
  710.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))
  711.         net_24_cal.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  712.         net_24_cal.blobs['data'].data[...] = caffe_img_resized_CHW
  713.         net_24_cal.forward()
  715.         output = net_24_cal.blobs['prob'].data
  717.         prediction = output[0]      # (44, 1) ndarray
  719.         threshold = 0.1
  720.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  722.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  724.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  725.             result.append(cur_rectangle)
  726.             continue
  728.         total_s_change = 0
  729.         total_x_change = 0
  730.         total_y_change = 0
  732.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  733.             cal_label = int(indices[current_cal])   # should be number in 0~44
  734.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  735.                 total_s_change += 0.83
  736.             elif (cal_label >= 9) and (cal_label <= 17):
  737.                 total_s_change += 0.91
  738.             elif (cal_label >= 18) and (cal_label <= 26):
  739.                 total_s_change += 1.0
  740.             elif (cal_label >= 27) and (cal_label <= 35):
  741.                 total_s_change += 1.10
  742.             else:
  743.                 total_s_change += 1.21
  745.             if cal_label % 9 <= 2:       # decide x change
  746.                 total_x_change += -0.17
  747.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  748.                 total_x_change += 0.17
  750.             if cal_label % 3 == 0:       # decide y change
  751.                 total_y_change += -0.17
  752.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  753.                 total_y_change += 0.17
  755.         s_change = total_s_change / number_of_cals      # calculate average
  756.         x_change = total_x_change / number_of_cals
  757.         y_change = total_y_change / number_of_cals
  759.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  760.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  761.         cur_result[1] = int(max(0, original_y1 - original_h * y_change / s_change))
  762.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  763.         cur_result[3] = int(min(height, cur_result[1] + original_h / s_change))
  765.         result.append(cur_result)
  767.     result = sorted(result, key=itemgetter(4), reverse=True)    # sort rectangles according to confidence                                                                       # reverse, so that it ranks from large to small
  769.     return result
  770. def detect_face_48c_net(net_48c, img_forward, rectangles):
  771.     '''
  772.     Adjusts net to take one crop of image only during test time
  773.     :param caffe_img: image in caffe style to detect faces
  774.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  775.     :return:    rectangles after calibration
  776.     '''
  777.     result = []
  778.     for cur_rectangle in rectangles:
  780.         x1 = cur_rectangle[0]
  781.         y1 = cur_rectangle[1]
  782.         x2 = cur_rectangle[2]
  783.         y2 = cur_rectangle[3]
  785.         cropped_caffe_img = img_forward[y1:y2, x1:x2]     # crop image
  787.         caffe_img_resized = cv2.resize(cropped_caffe_img, (48, 48))
  788.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))
  789.         net_48c.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  790.         net_48c.blobs['data'].data[...] = caffe_img_resized_CHW
  791.         net_48c.forward()
  793.         prediction = net_48c.blobs['prob'].data
  795.         confidence = prediction[0][1]
  797.         if confidence > 0.95:#0.1:
  798.             cur_rectangle[4] = confidence
  799.             result.append(cur_rectangle)
  801.     result = sorted(result, key=itemgetter(4), reverse=True)    # sort rectangles according to confidence
  802.                                                                         # reverse, so that it ranks from large to small #after sorter and globalnms the best faces will be detected
  803.     return result
  804. def cal_face_48c_net(net_48_cal, img_forward, rectangles):
  805.     '''
  806.     Adjusts net to take one crop of image only during test time
  807.     :param caffe_image: image in caffe style to detect faces
  808.     :param rectangles:  rectangles in form [x11, y11, x12, y12, confidence, current_scale]
  809.     :return:    rectangles after calibration
  810.     '''
  811.     height, width, channels = img_forward.shape
  812.     result = []
  813.     for cur_rectangle in rectangles:
  815.         original_x1 = cur_rectangle[0]
  816.         original_y1 = cur_rectangle[1]
  817.         original_x2 = cur_rectangle[2]
  818.         original_y2 = cur_rectangle[3]
  819.         original_w = original_x2 - original_x1
  820.         original_h = original_y2 - original_y1
  822.         cropped_caffe_img = img_forward[original_y1:original_y2, original_x1:original_x2] # crop image
  823.         caffe_img_resized = cv2.resize(cropped_caffe_img, (48, 48))
  824.         caffe_img_resized_CHW = caffe_img_resized.transpose((2, 0, 1))
  825.         net_48_cal.blobs['data'].reshape(1, *caffe_img_resized_CHW.shape)
  826.         net_48_cal.blobs['data'].data[...] = caffe_img_resized_CHW
  827.         net_48_cal.forward()
  829.         output = net_48_cal.blobs['prob'].data
  831.         prediction = output[0]      # (44, 1) ndarray
  833.         threshold = 0.1
  834.         indices = np.nonzero(prediction > threshold)[0]   # ndarray of indices where prediction is larger than threshold
  836.         number_of_cals = len(indices)   # number of calibrations larger than threshold
  838.         if number_of_cals == 0:     # if no calibration is needed, check next rectangle
  839.             result.append(cur_rectangle)
  840.             continue
  842.         total_s_change = 0
  843.         total_x_change = 0
  844.         total_y_change = 0
  846.         for current_cal in range(number_of_cals):       # accumulate changes, and calculate average
  847.             cal_label = int(indices[current_cal])   # should be number in 0~44
  848.             if (cal_label >= 0) and (cal_label <= 8):       # decide s change
  849.                 total_s_change += 0.83
  850.             elif (cal_label >= 9) and (cal_label <= 17):
  851.                 total_s_change += 0.91
  852.             elif (cal_label >= 18) and (cal_label <= 26):
  853.                 total_s_change += 1.0
  854.             elif (cal_label >= 27) and (cal_label <= 35):
  855.                 total_s_change += 1.10
  856.             else:
  857.                 total_s_change += 1.21
  859.             if cal_label % 9 <= 2:       # decide x change
  860.                 total_x_change += -0.17
  861.             elif (cal_label % 9 >= 6) and (cal_label % 9 <= 8):     # ignore case when 3<=x<=5, since adding 0 doesn't change
  862.                 total_x_change += 0.17
  864.             if cal_label % 3 == 0:       # decide y change
  865.                 total_y_change += -0.17
  866.             elif cal_label % 3 == 2:     # ignore case when 1, since adding 0 doesn't change
  867.                 total_y_change += 0.17
  869.         s_change = total_s_change / number_of_cals      # calculate average
  870.         x_change = total_x_change / number_of_cals
  871.         y_change = total_y_change / number_of_cals
  873.         cur_result = cur_rectangle      # inherit format and last two attributes from original rectangle
  874.         cur_result[0] = int(max(0, original_x1 - original_w * x_change / s_change))
  875.         cur_result[1] = int(max(0, original_y1 - 1.1 * original_h * y_change / s_change))
  876.         cur_result[2] = int(min(width, cur_result[0] + original_w / s_change))
  877.         cur_result[3] = int(min(height, cur_result[1] + 1.1 * original_h / s_change))
  879.         result.append(cur_result)
  881.     return result
  883. def detect_faces_net(nets, img_forward, min_face_size, stride,
  884.                  multiScale=False, scale_factor=1.414, threshold=0.05):
  885.     '''
  886.     Complete flow of face cascade detection
  887.     :param nets: 6 nets as a tuple
  888.     :param img_forward: image in normal style after subtracting mean pixel value
  889.     :param min_face_size:
  890.     :param stride:
  891.     :param multiScale:
  892.     :param scale_factor:
  893.     :param threshold:
  894.     :return: list of rectangles
  895.     '''
  896.     net_12c_full_conv = nets[0]
  897.     net_12_cal = nets[1]
  898.     net_24c = nets[2]
  899.     net_24_cal = nets[3]
  900.     net_48c = nets[4]
  901.     net_48_cal = nets[5]
  903.     rectangles = detect_face_12c_net(net_12c_full_conv, img_forward, min_face_size,
  904.                                  stride, multiScale, scale_factor, threshold)  # detect faces
  905.     rectangles = cal_face_12c_net(net_12_cal, img_forward, rectangles)      # calibration
  906.     rectangles = localNMS(rectangles)      # apply local NMS
  907.     rectangles = detect_face_24c_net(net_24c, img_forward, rectangles)
  908.     rectangles = cal_face_24c_net(net_24_cal, img_forward, rectangles)      # calibration
  909.     rectangles = localNMS(rectangles)      # apply local NMS
  910.     rectangles = detect_face_48c_net(net_48c, img_forward, rectangles)
  911.     rectangles = globalNMS(rectangles)      # apply global NMS
  912.     rectangles = cal_face_48c_net(net_48_cal, img_forward, rectangles)      # calibration
  914.     return rectangles

发表评论

表情：
评论列表 （有 0 条评论，382人围观）

还没有评论，来说两句吧...

相关阅读

    相关 人脸检测（三）

    3.OpenCV人脸检测方法 采用的是harr-like特征提取 + adaboost级联分类器构成的人脸检测算法，可以设置要检测的人脸大小范围，召回率高，但有时会出现误检

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 511 阅读

    相关 人脸识别系统_人脸检测

    项目：基于人脸识别的无卡ATM机模拟系统 主要实现内容： 包括实现AMT机模拟人脸识别和密码输入、PC端模拟实现储户数据库服务器系统。 1. ATM模拟端实现采用手

    亦凉亦凉/ 0 赞/ 478 阅读