Beispiel #1
0
 def __init__(self, args):
     self.args = args
     # if args.display:
     #     cv2.namedWindow("test", cv2.WINDOW_NORMAL)
     #     cv2.resizeWindow("test", args.display_width, args.display_height)
     self.open_video()
     #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.use_cuda, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
     self.command_type = args.mot_type
     threshold = np.array([0.7, 0.8, 0.9])
     crop_size = [112, 112]
     if self.command_type == 'face':
         self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)
     elif self.command_type == 'person':
         self.person_detect = RetinanetDetector(args)
     self.deepsort = DeepSort(args.feature_model,
                              args.face_load_num,
                              use_cuda=args.use_cuda,
                              mot_type=self.command_type)
     self.kf = KalmanFilter()
     self.meanes_track = []
     self.convariances_track = []
     self.id_cnt_dict = dict()
     self.moveTrack = MoveTrackerRun(self.kf)
     self.img_clarity = BlurDetection()
     self.score = 60.0
 def __init__(self, args):
     self.args = args
     self.open_video()
     #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.ctx, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
     self.command_type = args.mot_type
     threshold = np.array([0.7, 0.8, 0.9])
     crop_size = [112, 112]
     if self.command_type == 'face':
         self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)
     elif self.command_type == 'person':
         self.person_detect = RetinanetDetector(args)
     elif self.command_type == 'head':
         self.head_detect = HeadDetect(args)
     self.kf = KalmanFilter()
     self.deepsort = DeepSort(args.feature_model,
                              args.face_load_num,
                              mot_type=args.mot_type)
     self.meanes_track = []
     self.convariances_track = []
     self.id_cnt_dict = dict()
     self.tracker_run = TrackerRun(args.tracker_type)
     self.moveTrack = MoveTrackerRun(self.kf)
     self.img_clarity = BlurDetection()
     self.score = 60.0
     self.in_num = 0
     self.out_num = 0
Beispiel #3
0
def evalu_img(imgpath, min_size):
    #cv2.namedWindow("test")
    #cv2.moveWindow("test",1400,10)
    threshold = np.array([0.5, 0.7, 0.8])
    base_name = "test_img"
    save_dir = './output'
    crop_size = [112, 112]
    #detect_model = MTCNNDet(min_size,threshold)
    detect_model = MtcnnDetector(min_size, threshold)
    #alignface = Align_img(crop_size)
    img = cv2.imread(imgpath)
    h, w = img.shape[:2]
    if config.img_downsample and h > 1000:
        img = img_ratio(img, 720)
    rectangles = detect_model.detectFace(img)
    #draw = img.copy()
    if len(rectangles) > 0:
        points = np.array(rectangles)
        #print('rec shape',points.shape)
        points = points[:, 5:]
        #print("landmarks: ",points)
        points_list = points.tolist()
        crop_imgs = alignImg(img, crop_size, points_list)
        #crop_imgs = alignImg_opencv(img,crop_size,points_list)
        #crop_imgs = alignface.extract_image_chips(img,points_list)
        #crop_imgs = alignImg_angle(img,crop_size,points_list)
        for idx_cnt, img_out in enumerate(crop_imgs):
            savepath = os.path.join(save_dir,
                                    base_name + '_' + str(idx_cnt) + ".jpg")
            #img_out = cv2.resize(img_out,(96,112))
            #cv2.imshow("test",img_out)
            cv2.imwrite(savepath, img_out)
        for rectangle in rectangles:
            score_label = str("{:.2f}".format(rectangle[4]))
            cv2.putText(img, score_label,
                        (int(rectangle[0]), int(rectangle[1])),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0))
            cv2.rectangle(img, (int(rectangle[0]), int(rectangle[1])),
                          (int(rectangle[2]), int(rectangle[3])), (255, 0, 0),
                          1)
            if len(rectangle) > 5:
                if config.x_y:
                    for i in range(5, 15, 2):
                        cv2.circle(
                            img,
                            (int(rectangle[i + 0]), int(rectangle[i + 1])), 2,
                            (0, 255, 0))
                else:
                    rectangle = rectangle[5:]
                    for i in range(5):
                        cv2.circle(img,
                                   (int(rectangle[i]), int(rectangle[i + 5])),
                                   2, (0, 255, 0))
    else:
        print("No face detected")
Beispiel #4
0
    def __init__(self, args):
        self.args = args
        if args.display:
            cv2.namedWindow("test")  #cv2.WINDOW_NORMAL)
            #cv2.resizeWindow("test", args.display_width, args.display_height)

        self.vdo = cv2.VideoCapture()
        #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.use_cuda, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
        threshold = np.array([0.7, 0.8, 0.9])
        crop_size = [112, 112]
        self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)
Beispiel #5
0
class MOTTracker(object):
    def __init__(self, args):
        self.args = args
        # if args.display:
        #     cv2.namedWindow("test", cv2.WINDOW_NORMAL)
        #     cv2.resizeWindow("test", args.display_width, args.display_height)
        self.open_video()
        #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.use_cuda, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
        self.command_type = args.mot_type
        threshold = np.array([0.7, 0.8, 0.9])
        crop_size = [112, 112]
        if self.command_type == 'face':
            self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)
        elif self.command_type == 'person':
            self.person_detect = RetinanetDetector(args)
        self.deepsort = DeepSort(args.feature_model,
                                 args.face_load_num,
                                 use_cuda=args.use_cuda,
                                 mot_type=self.command_type)
        self.kf = KalmanFilter()
        self.meanes_track = []
        self.convariances_track = []
        self.id_cnt_dict = dict()
        self.moveTrack = MoveTrackerRun(self.kf)
        self.img_clarity = BlurDetection()
        self.score = 60.0

    def open_video(self):
        if not os.path.isfile(self.args.VIDEO_PATH):
            raise Exception("Error:input video path is not exist")
        self.vdo = cv2.VideoCapture(self.args.VIDEO_PATH)
        self.im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
        if self.args.save_dir:
            if not os.path.exists(self.args.save_dir):
                os.makedirs(self.args.save_dir)
            #fourcc =  cv2.VideoWriter_fourcc(*'MJPG')
            #self.output = cv2.VideoWriter(self.args.save_path, fourcc, 20, (self.im_width,self.im_height))
        if not self.vdo.isOpened():
            raise Exception('open video failed')

    def xcycah2xcyc(self, xyah):
        xyah = np.array(xyah)
        xyah = xyah[:, :4]
        w = xyah[:, 2] * xyah[:, 3]
        h = xyah[:, 3]
        xc = xyah[:, 0]  #+ w/2
        yc = xyah[:, 1]  #+ h/2
        return np.vstack([xc, yc, w, h]).T

    def xcycah2xyxy(self, xcycah):
        xcycah = np.array(xcycah)
        xcycah = xcycah[:, :4]
        w = xcycah[:, 2] * xcycah[:, 3]
        h = xcycah[:, 3]
        x2 = xcycah[:, 0] + w / 2
        y2 = xcycah[:, 1] + h / 2
        x1 = xcycah[:, 0] - w / 2
        y1 = xcycah[:, 1] - h / 2
        return np.vstack([x1, y1, x2, y2]).T

    def xyxy2xcyc(self, xywh):
        w = xywh[:, 2] - xywh[:, 0]
        h = xywh[:, 3] - xywh[:, 1]
        xc = xywh[:, 0] + w / 2
        yc = xywh[:, 1] + h / 2
        return np.vstack([xc, yc, w, h]).T

    def xyxy2xywh(self, xywh):
        w = xywh[:, 2] - xywh[:, 0]
        h = xywh[:, 3] - xywh[:, 1]
        return np.vstack([xywh[:, 0], xywh[:, 1], w, h]).T

    def xywh2xcycwh(self, xywh):
        xywh = np.array(xywh)
        xc = xywh[:, 0] + xywh[:, 2] / 2
        yc = xywh[:, 1] + xywh[:, 3] / 2
        return np.vstack([xc, yc, xywh[:, 2], xywh[:, 3]]).T

    def xywh2xyxy(self, xywh):
        xywh = np.array(xywh)
        x2 = xywh[:, 0] + xywh[:, 2]
        y2 = xywh[:, 1] + xywh[:, 3]
        return np.vstack([xywh[:, 0], xywh[:, 1], x2, y2]).T

    def xcyc2xcycah(self, bbox_xcycwh):
        bbox_xcycwh = np.array(bbox_xcycwh, dtype=np.float32)
        xc = bbox_xcycwh[:, 0]  #- bbox_xcycwh[:,2]/2
        yc = bbox_xcycwh[:, 1]  #- bbox_xcycwh[:,3]/2
        a = bbox_xcycwh[:, 2] / bbox_xcycwh[:, 3]
        return np.vstack([xc, yc, a, bbox_xcycwh[:, 3]]).T

    def widerbox(self, boxes):
        x1 = boxes[:, 0]
        y1 = boxes[:, 1]
        x2 = boxes[:, 2]
        y2 = boxes[:, 3]
        boxw = x2 - x1
        boxh = y2 - y1
        x1 = np.maximum(0, x1 - 0.3 * boxw)
        y1 = np.maximum(0, y1 - 0.3 * boxh)
        x2 = np.minimum(self.im_width, x2 + 0.3 * boxw)
        y2 = np.minimum(self.im_height, y2 + 0.3 * boxh)
        return np.vstack([x1, y1, x2, y2]).T

    def save_track_results(self, bbox_xyxy, img, identities, offset=[0, 0]):
        for i, box in enumerate(bbox_xyxy):
            x1, y1, x2, y2 = [int(i) for i in box]
            x1 += offset[0]
            x2 += offset[0]
            y1 += offset[1]
            y2 += offset[1]
            x1 = min(max(x1, 0), self.im_width - 1)
            y1 = min(max(y1, 0), self.im_height - 1)
            x2 = min(max(x2, 0), self.im_width - 1)
            y2 = min(max(y2, 0), self.im_height - 1)
            # box text and bar
            id = str(identities[i]) if identities is not None else '0'
            crop_img = img[y1:y2, x1:x2, :]
            if self.img_clarity._blurrDetection(crop_img) > self.score:
                tmp_cnt = self.id_cnt_dict.setdefault(id, 0)
                self.id_cnt_dict[id] = tmp_cnt + 1
                save_dir = os.path.join(self.args.save_dir, id)
                if not os.path.exists(save_dir):
                    os.makedirs(save_dir)
                save_path = os.path.join(save_dir,
                                         id + '_' + str(tmp_cnt) + '.jpg')
                cv2.imwrite(save_path, crop_img)
            else:
                continue

    def detect(self):
        cnt = 0
        update_fg = True
        detect_fg = True
        total_time = 0
        outputs = []
        while self.vdo.isOpened():
            start = time.time()
            _, ori_im = self.vdo.read()
            im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
            im = np.array([im])
            if cnt % 5 == 0 or detect_fg:
                # bbox_xcycwh, cls_conf, cls_ids = self.yolo3(im)
                # mask = cls_ids==0
                # bbox_xcycwh = bbox_xcycwh[mask]
                # bbox_xcycwh[:,3:] *= 1.2
                # cls_conf = cls_conf[mask]
                if self.command_type == 'face':
                    rectangles = self.mtcnn.detectFace(im, True)
                    rectangles = rectangles[0]
                    if len(rectangles) < 1:
                        continue
                    bboxes = rectangles[:, :4]
                    bboxes = self.widerbox(bboxes)
                    #
                    bbox_xcycwh = self.xyxy2xcyc(bboxes)
                    cls_conf = rectangles[:, 4]
                elif self.command_type == 'person':
                    bboxes, cls_conf = self.person_detect.test_img_org(ori_im)
                    if len(bboxes) == 0:
                        continue
                    bbox_xcycwh = self.xywh2xcycwh(bboxes)
                #outputs = bboxes #self.xywh2xyxy(bboxes)
                update_fg = True
                box_xcycah = self.xcyc2xcycah(bbox_xcycwh)
                self.moveTrack.track_init(box_xcycah)
                self.moveTrack.track_predict()
                self.moveTrack.track_update(box_xcycah)
                # detect_xywh = self.xyxy2xywh(bboxes) if self.command_type=='face' else bboxes
                # self.tracker_run.init(ori_im,detect_xywh.tolist())
                detect_fg = False
            else:
                if len(bbox_xcycwh) > 0:
                    start1 = time.time()
                    self.moveTrack.track_predict()
                    bbox_xcycwh = self.xcycah2xcyc(self.moveTrack.means_track)
                    #outputs = self.xcycah2xyxy(self.moveTrack.means_track)
                    # boxes_tmp = self.tracker_run.update(ori_im)
                    # bbox_xcycwh = self.xywh2xcycwh(boxes_tmp)
                    end1 = time.time()
                    print('only tracker time consume:', end1 - start1)
                    #outputs = self.xywh2xyxy(boxes_tmp)
                    update_fg = False
                    detect_fg = False
                else:
                    detect_fg = True
            if len(bbox_xcycwh) > 0:
                outputs = self.deepsort.update(bbox_xcycwh, cls_conf, ori_im,
                                               update_fg)
            end = time.time()
            consume = end - start
            if len(outputs) > 0:
                #outputs = rectangles
                bbox_xyxy = outputs[:, :4]
                identities = outputs[:, -1]  #np.zeros(outputs.shape[0])
                ori_im = draw_bboxes(ori_im, bbox_xyxy, identities)
                #self.save_track_results(bbox_xyxy,ori_im,identities)
            print("frame: {} time: {}s, fps: {}".format(
                cnt, consume, 1 / (end - start)))
            cnt += 1
            cv2.imshow("test", ori_im)
            c = cv2.waitKey(1) & 0xFF
            if c == 27 or c == ord('q'):
                break
            #if self.args.save_path:
            #   self.output.write(ori_im)
            total_time += consume
        self.vdo.release()
        cv2.destroyAllWindows()
        print("video ave fps and total_time: ", cnt / total_time, total_time)
class MOTTracker(object):
    def __init__(self, args):
        self.args = args
        self.open_video()
        #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.ctx, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
        self.command_type = args.mot_type
        threshold = np.array([0.7, 0.8, 0.9])
        crop_size = [112, 112]
        if self.command_type == 'face':
            self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)
        elif self.command_type == 'person':
            self.person_detect = RetinanetDetector(args)
        elif self.command_type == 'head':
            self.head_detect = HeadDetect(args)
        self.kf = KalmanFilter()
        self.deepsort = DeepSort(args.feature_model,
                                 args.face_load_num,
                                 mot_type=args.mot_type)
        self.meanes_track = []
        self.convariances_track = []
        self.id_cnt_dict = dict()
        self.tracker_run = TrackerRun(args.tracker_type)
        self.moveTrack = MoveTrackerRun(self.kf)
        self.img_clarity = BlurDetection()
        self.score = 60.0
        self.in_num = 0
        self.out_num = 0

    def open_video(self):
        if not os.path.isfile(self.args.VIDEO_PATH):
            raise Exception("Error:input video path is not exist")
        self.vdo = cv2.VideoCapture(self.args.VIDEO_PATH)
        self.im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
        if self.args.save_dir:
            if not os.path.exists(self.args.save_dir):
                os.makedirs(self.args.save_dir)
            #fourcc =  cv2.VideoWriter_fourcc(*'MJPG')
            #self.output = cv2.VideoWriter(self.args.save_path, fourcc, 20, (self.im_width,self.im_height))
        if not self.vdo.isOpened():
            raise Exception('open video failed')

    def xyxy2xcyc(self, xywh):
        w = xywh[:, 2] - xywh[:, 0]
        h = xywh[:, 3] - xywh[:, 1]
        xc = xywh[:, 0] + w / 2
        yc = xywh[:, 1] + h / 2
        return np.vstack([xc, yc, w, h]).T

    def xyxy2xywh(self, xywh):
        w = xywh[:, 2] - xywh[:, 0]
        h = xywh[:, 3] - xywh[:, 1]
        return np.vstack([xywh[:, 0], xywh[:, 1], w, h]).T

    def xywh2xcycwh(self, xywh):
        xywh = np.array(xywh)
        xc = xywh[:, 0] + xywh[:, 2] / 2
        yc = xywh[:, 1] + xywh[:, 3] / 2
        return np.vstack([xc, yc, xywh[:, 2], xywh[:, 3]]).T

    def widerbox(self, boxes):
        x1 = boxes[:, 0]
        y1 = boxes[:, 1]
        x2 = boxes[:, 2]
        y2 = boxes[:, 3]
        boxw = x2 - x1
        boxh = y2 - y1
        x1 = np.maximum(0, x1 - 0.3 * boxw)
        y1 = np.maximum(0, y1 - 0.3 * boxh)
        x2 = np.minimum(self.im_width, x2 + 0.3 * boxw)
        y2 = np.minimum(self.im_height, y2 + 0.3 * boxh)
        return np.vstack([x1, y1, x2, y2]).T

    def save_track_results(self, bbox_xyxy, img, identities, offset=[0, 0]):
        for i, box in enumerate(bbox_xyxy):
            x1, y1, x2, y2 = [int(i) for i in box]
            x1 += offset[0]
            x2 += offset[0]
            y1 += offset[1]
            y2 += offset[1]
            x1 = min(max(x1, 0), self.im_width - 1)
            y1 = min(max(y1, 0), self.im_height - 1)
            x2 = min(max(x2, 0), self.im_width - 1)
            y2 = min(max(y2, 0), self.im_height - 1)
            # box text and bar
            id = str(identities[i]) if identities is not None else '0'
            crop_img = img[y1:y2, x1:x2, :]
            if self.img_clarity._blurrDetection(crop_img) > self.score:
                tmp_cnt = self.id_cnt_dict.setdefault(id, 0)
                self.id_cnt_dict[id] = tmp_cnt + 1
                save_dir = os.path.join(self.args.save_dir, id)
                if not os.path.exists(save_dir):
                    os.makedirs(save_dir)
                save_path = os.path.join(save_dir,
                                         id + '_' + str(tmp_cnt) + '.jpg')
                cv2.imwrite(save_path, crop_img)
            else:
                continue

    def show_bboxs(self, img, bbox, identities=None, fgs=[]):
        imh, imw = img.shape[:2]
        for i, box in enumerate(bbox):
            box = list(map(int, box))
            x1, y1, x2, y2 = box
            h = y2 - y1
            tm_fg = fgs[i]
            if tm_fg == 0:
                self.out_num += 1
            elif tm_fg == 1:
                self.in_num += 1
            # box text and bar
            id = int(identities[i]) if identities is not None else 0
            color = COLORS_10[id % len(COLORS_10)]
            label = '{}{:d}'.format("", id)
            #t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 2 , 2)[0]
            cv2.rectangle(img, (x1, y1), (x2, y2), color, 4)
            #cv2.rectangle(img,(x1, y1),(x1+t_size[0]+3,y1+t_size[1]+4), color,-1)
            #cv2.putText(img,label,(x1,y1+t_size[1]+4), 0, 1e-2*h, [255,255,255], 1)
            cv2.putText(img, label, (x1, y1 + 4), 0, 1e-2 * h, [255, 255, 255],
                        4)
        txt = "in:{}  out:{}".format(self.in_num, self.out_num)
        cv2.putText(img, txt, (imw - 100, 20), 0, 0.5, [0, 0, 255], 2)
        cv2.line(img, (0, 150), (imw - 1, 150), (255, 0, 0), 2, 4)
        return img

    def detect(self):
        cnt = 0
        update_fg = True
        detect_fg = True
        total_time = 0
        outputs = []
        while self.vdo.isOpened():
            start = time.time()
            _, ori_im = self.vdo.read()
            im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
            im = np.array([im])
            if cnt % 20 == 0 or detect_fg:
                # bbox_xcycwh, cls_conf, cls_ids = self.yolo3(im)
                # mask = cls_ids==0
                # bbox_xcycwh = bbox_xcycwh[mask]
                # bbox_xcycwh[:,3:] *= 1.2
                # cls_conf = cls_conf[mask]
                if self.command_type == 'face':
                    rectangles = self.mtcnn.detectFace(im, True)
                    rectangles = rectangles[0]
                    if len(rectangles) < 1:
                        continue
                    bboxes = rectangles[:, :4]
                    bboxes = self.widerbox(bboxes)
                    #
                    bbox_xcycwh = self.xyxy2xcyc(bboxes)
                    cls_conf = rectangles[:, 4]
                elif self.command_type == 'person':
                    bboxes, cls_conf = self.person_detect.test_img_org(ori_im)
                    if len(bboxes) == 0:
                        continue
                    bbox_xcycwh = self.xywh2xcycwh(bboxes)
                elif self.command_type == 'head':
                    bboxes, cls_conf = self.head_detect.inference_img(ori_im)
                    if len(bboxes) == 0:
                        continue
                    bbox_xcycwh = self.xywh2xcycwh(bboxes)
                #outputs = bboxes #self.xywh2xyxy(bboxes)
                update_fg = True
                # box_xcycah = self.xcyc2xcycah(bbox_xcycwh)
                # self.moveTrack.track_init(box_xcycah)
                # self.moveTrack.track_predict()
                # self.moveTrack.track_update(box_xcycah)
                detect_xywh = self.xyxy2xywh(
                    bboxes) if self.command_type == 'face' else bboxes
                self.tracker_run.init(ori_im, detect_xywh.tolist())
                detect_fg = False
            else:
                #print('************here')
                if len(bbox_xcycwh) > 0:
                    #self.moveTrack.track_predict()
                    #bbox_xcycwh = self.xcycah2xcyc(self.means_track)
                    #outputs = self.xcycah2xyxy(self.moveTrack.means_track)
                    start1 = time.time()
                    boxes_tmp = self.tracker_run.update(ori_im)
                    bbox_xcycwh = self.xywh2xcycwh(boxes_tmp)
                    end1 = time.time()
                    print('only tracker time consume:', end1 - start1)
                    #outputs = self.xywh2xyxy(boxes_tmp)
                    update_fg = False
                    detect_fg = False
                else:
                    detect_fg = True
            if len(bbox_xcycwh) > 0:
                outputs = self.deepsort.update(bbox_xcycwh, cls_conf, ori_im,
                                               update_fg)
            end = time.time()
            consume = end - start
            if len(outputs) > 0:
                #outputs = rectangles
                bbox_xyxy = outputs[:, :4]
                identities = outputs[:, 4]  #np.zeros(outputs.shape[0])
                fgs = outputs[:, -1]
                #ori_im = draw_bboxes(ori_im, bbox_xyxy, identities)
                ori_im = self.show_bboxs(ori_im, bbox_xyxy, identities, fgs)
                #self.save_track_results(bbox_xyxy,ori_im,identities)
            print("frame: {} time: {}s, fps: {}".format(
                cnt, consume, 1 / (end - start)))
            cnt += 1
            cv2.imshow("test", ori_im)
            c = cv2.waitKey(1) & 0xFF
            if c == 27 or c == ord('q'):
                break
            #if self.args.save_path:
            #   self.output.write(ori_im)
            total_time += consume
        self.vdo.release()
        cv2.destroyAllWindows()
        print("video ave fps and total_time: ", cnt / total_time, total_time)
Beispiel #7
0
class Demo(object):
    def __init__(self, args):
        self.args = args
        if args.display:
            cv2.namedWindow("test")  #cv2.WINDOW_NORMAL)
            #cv2.resizeWindow("test", args.display_width, args.display_height)

        self.vdo = cv2.VideoCapture()
        #self.yolo3 = YOLOv3(args.yolo_cfg, args.yolo_weights, args.yolo_names,use_cuda=args.use_cuda, is_xywh=True, conf_thresh=args.conf_thresh, nms_thresh=args.nms_thresh)
        threshold = np.array([0.7, 0.8, 0.9])
        crop_size = [112, 112]
        self.mtcnn = MtcnnDetector(threshold, crop_size, args.detect_model)

    def __enter__(self):
        assert os.path.isfile(self.args.VIDEO_PATH), "Error: path error"
        self.vdo.open(self.args.VIDEO_PATH)
        self.im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
        assert self.vdo.isOpened()
        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):
        if exc_type:
            print(exc_type, exc_value, exc_traceback)

    def draw_bboxes(self, img, bbox, identities=None, offset=(0, 0)):
        for i, box in enumerate(bbox):
            x1, y1, x2, y2 = [int(i) for i in box]
            x1 += offset[0]
            x2 += offset[0]
            y1 += offset[1]
            y2 += offset[1]
            h = y2 - y1
            # box text and bar
            id = int(identities[i]) if identities is not None else 0
            color = COLORS_10[id % len(COLORS_10)]
            label = '{}{:d}'.format("", id)
            #t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 2 , 2)[0]
            cv2.rectangle(img, (x1, y1), (x2, y2), color, 1)
            #cv2.rectangle(img,(x1, y1),(x1+t_size[0]+3,y1+t_size[1]+4), color,-1)
            #cv2.putText(img,label,(x1,y1+t_size[1]+4), 0, 1e-2*h, [255,255,255], 1)
            cv2.putText(img, label, (x1, y1 + 4), 0, 1e-2 * h, [255, 255, 255],
                        1)
        return img

    def detect(self):
        while self.vdo.grab():
            _, ori_im = self.vdo.retrieve()
            im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
            im = np.array([im])
            rectangles = self.mtcnn.detectFace(im, True)
            rectangles = rectangles[0]
            if len(rectangles) < 1:
                continue
            outputs = rectangles[:, :4]
            if len(outputs) > 0:
                #outputs = rectangles
                bbox_xyxy = outputs[:, :4]
                identities = outputs[:, -1]  #np.zeros(show_box.shape[0]) #
                ori_im = self.draw_bboxes(ori_im, bbox_xyxy, identities)
            cv2.imshow("test", ori_im)
            c = cv2.waitKey(1) & 0xFF
            if c == 27 or c == ord('q'):
                break
        self.vdo.release()
        cv2.destroyAllWindows()
Beispiel #8
0
def save_cropfromtxt(file_in, base_dir, save_dir, crop_size, name):
    '''
    file_in: images path recorded
    base_dir: images locate in 
    save_dir: detect faces saved in
    fun: saved id images, save name is the same input image
    '''
    f_ = open(file_in, 'r')
    f_out = './output/%s_face.txt' % name
    failed_w = open(f_out, 'w')
    lines_ = f_.readlines()
    min_size = 50  #15
    threshold = np.array([0.8, 0.8, 0.9])
    #detect_model = MTCNNDet(min_size,threshold)
    detect_model = MtcnnDetector(min_size, threshold)
    #model_path = "../models/haarcascade_frontalface_default.xml"
    #detect_model = FaceDetector_Opencv(model_path)
    if os.path.exists(save_dir):
        pass
    else:
        os.makedirs(save_dir)
    idx_cnt = 0
    sizefailed_cnt = 0
    blurfailed_cnt = 0
    if config.show:
        cv2.namedWindow("src")
        cv2.namedWindow("crop")
        cv2.moveWindow("crop", 650, 10)
        cv2.moveWindow("src", 100, 10)
    total_item = len(lines_)
    for i in tqdm(range(total_item)):
        line_1 = lines_[i]
        line_1 = line_1.strip()
        img_path = os.path.join(base_dir, line_1)
        img = cv2.imread(img_path)
        if img is None:
            print("img is none,", img_path)
            continue
        h, w = img.shape[:2]
        if config.img_downsample and max(w, h) > 1080:
            img = img_ratio(img, 640)
        line_s = line_1.split("/")
        img_name = line_s[-1]
        new_dir = '/'.join(line_s[:-1])
        rectangles = detect_model.detectFace(img)
        if len(rectangles) > 0:
            idx_cnt += 1
            rectangles = sort_box(rectangles)
            #rectangles = check_boxes(rectangles,30)
            if rectangles is None:
                failed_w.write(img_path)
                failed_w.write('\n')
                sizefailed_cnt += 1
                continue
            #print("box",np.shape(rectangles))
            if not config.crop_org:
                points = np.array(rectangles)
                points = points[:, 5:]
                points_list = points.tolist()
                points_list = [points_list[0]]
                img_out = alignImg(img, crop_size, points_list)
                #img_out = alignImg_opencv(img,crop_size,points_list)
                #img_out = alignImg_angle(img,crop_size,points_list)
                img_out = img_out[0]
            else:
                img_out = img_crop(img, rectangles[0])
                #savepath = os.path.join(save_dir,str(idx_cnt)+".jpg")
                if config.imgpad:
                    img_out = Img_Pad(img_out, crop_size)
                else:
                    img_out = cv2.resize(img_out, (crop_size[1], crop_size[0]))
            '''
            face_score = blurness(img_out)
            if face_score < 100:
                failed_w.write(img_path)
                failed_w.write('\n')
                blurfailed_cnt+=1
                continue
            '''
            line_1 = line_1.split('.')[0] + '.png'
            savepath = os.path.join(save_dir, line_1)
            cv2.imwrite(savepath, img_out)
            cv2.waitKey(10)
            #cv2.imwrite(savepath,img)
            if config.show:
                label_show(img, rectangles)
                cv2.imshow("crop", img_out)
                cv2.waitKey(100)
        else:
            failed_w.write(img_path)
            failed_w.write('\n')
            print("failed ", img_path)
        if config.show:
            cv2.imshow("src", img)
            cv2.waitKey(10)
    failed_w.close()
    f_.close()
    print("size less 112: ", sizefailed_cnt)
    print("blur less 100: ", blurfailed_cnt)