def draw_trackers(image,
                  tracks,
                  accumulation_gender=True,
                  accumulation_age=True,
                  show_both=False):
    '''
    show_both: True will show accumulate_current
    '''
    for track in tracks:
        if not track.is_confirmed() or track.time_since_update > 0:
            continue
        xmin, ymin, xmax, ymax = [int(x) for x in track.to_tlbr()]
        color = create_unique_color(track.track_id)

        # draw bbox
        cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)
        # track id
        label = str(track.track_id)
        text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
        cv2.rectangle(
            image, (xmin, ymin),
            (xmin + 10 + text_size[0][0], ymin + 10 + text_size[0][1]), color,
            -1)
        cv2.putText(image, label, (xmin + 5, ymin + 5 + text_size[0][1]),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)

        # draw info
        font_scale = 1
        font = cv2.FONT_HERSHEY_SIMPLEX
        thickness = 2
        # Gender
        gender = []
        if len(track.genders) > 0:
            if accumulation_gender:
                # return accumulate gender
                gender.append("F") if np.mean(
                    track.genders) <= 0.6 else gender.append("M")
                if show_both:
                    # gender = "F" if np.mean(track.genders) <= 0.6 else "M"
                    gender.append(
                        "F") if track.genders[-1] < 0.5 else gender.append("M")

            else:
                gender = "F" if track.genders[-1] < 0.5 else "M"

        else:
            gender = "N/A"
        # Age
        age = []
        if len(track.ages) > 0:
            if accumulation_age:
                # age = str(int(np.mean(track.ages)))
                age.append(str(int(np.mean(track.ages))))
                if show_both:
                    age.append(str(int(track.ages[-1])))
            else:
                age.append(str(int(track.ages[-1])))
        else:
            age.append("N/A")

        # GENDER AGE
        gen_age = "_".join(gender) + "_".join(age)
        text_size = cv2.getTextSize(gen_age, font, font_scale, thickness)
        txt_loc = (xmin, ymax + 10 + text_size[0][1])
        cv2.putText(image,
                    text=gen_age,
                    org=txt_loc,
                    fontFace=font,
                    fontScale=font_scale,
                    color=color,
                    thickness=thickness)

        # EXPR
        text_size = cv2.getTextSize(track.expr, font, font_scale, thickness)
        txt_loc = (xmin, ymax + 30 + 2 * text_size[0][1])
        cv2.putText(image,
                    text=track.expr,
                    org=txt_loc,
                    fontFace=font,
                    fontScale=font_scale,
                    color=color,
                    thickness=thickness)
Esempio n. 2
0
def put_text(img, x, y, text, color):
    fontFace = cv2.FONT_HERSHEY_SIMPLEX
    fontScale = 1
    thickness = 1
    boxsize, baseline = cv2.getTextSize(text, fontFace, fontScale, thickness)
    cv2.putText(img, text, (x, y + boxsize[1]), fontFace, thickness, color)
Esempio n. 3
0
def criaTeclado(index,letra,selector):
    
    if index == 0:
       x = 0
       y = 0
    elif index == 1:
        x = 70
        y = 0
    elif index == 2:
        x = 140
        y = 0
    elif index == 3:
        x = 210
        y = 0
    elif index == 4:
        x = 280
        y = 0
    elif index == 5:
        x = 350
        y = 0
    elif index == 6:
        x = 420
        y = 0
    elif index == 7:
        x = 490
        y = 0
        
    elif index == 8:
        x = 560
        y = 0
    
    elif index == 9:
        x = 630
        y = 0

    elif index == 10:
        x = 0
        y = 70
    
    elif index == 11:
        x = 70
        y = 70
    
    elif index == 12:
        x = 140
        y = 70
    
    elif index == 13:
        x = 210
        y = 70
    
    elif index == 14:
        x = 280
        y = 70
    
    elif index == 15:
        x = 350
        y = 70
    
    elif index == 16:
        x = 420
        y = 70
    
    elif index == 17:
        x = 490
        y = 70
        
    elif index == 18:
        x = 560
        y = 70
    
    elif index == 19:
        x = 630
        y = 70
    
    elif index == 20:
        x = 0
        y = 140
    
    elif index == 21:
        x = 70
        y = 140
    
    elif index == 22:
        x = 140
        y = 140
    
    elif index == 23:
        x = 210
        y = 140
        
    elif index == 24:
        x = 280
        y = 140
        
    elif index == 25:
        x = 350
        y = 140
        
    elif index == 26:
        x = 420
        y = 140
    
    
        
    # Teclas

    width = 70
    height = 70
    th = 2
    
    if selector is True:
        cv2.rectangle(teclado, (x + th, y + th), (x + width - th, y + height - th), (255, 255, 255), -1)
    else:
        cv2.rectangle(teclado, (x + th, y + th), (x + width - th, y + height - th), (255, 0, 0), th)
    
    # Texto 
    font_scale = 5
    text_size = cv2.getTextSize(letra, cv2.FONT_HERSHEY_PLAIN, font_scale, 2)[0]
    width_text, height_text = text_size[0], text_size[1]
    text_x = int((width - width_text) / 2) + x
    text_y = int((height + height_text) / 2) + y
    cv2.putText(teclado, letra, (text_x, text_y), cv2.FONT_HERSHEY_PLAIN, font_scale, (255, 0, 0), 2)
Esempio n. 4
0
    # pass the blob through the network and obtain the detections and
    # predictions
    net.setInput(blob)
    detections = net.forward()

    # put 'esc' text on frame
    font_scale = 0.5
    font = cv2.FONT_HERSHEY_COMPLEX
    # set the rectangle background to white
    rectangle_bgr = (0, 0, 0)
    # set some text
    text = "Press 'esc' to exit"
    # get the width and height of the text box
    (text_width, text_height) = cv2.getTextSize(text,
                                                font,
                                                fontScale=font_scale,
                                                thickness=1)[0]
    # set the text start position
    text_offset_x = 0
    text_offset_y = frame.shape[0] - 4
    # make the coords of the box with a small padding of two pixels
    box_coords = ((text_offset_x, text_offset_y),
                  (text_offset_x + text_width + 2,
                   text_offset_y - text_height + 2))
    cv2.rectangle(frame, box_coords[0], box_coords[1], rectangle_bgr,
                  cv2.FILLED)
    cv2.putText(frame,
                text, (text_offset_x, text_offset_y),
                font,
                fontScale=font_scale,
                color=(0, 255, 0),
Esempio n. 5
0
def draw_bbox(image,
              bboxes,
              classes=read_class_names(cfg.YOLO.CLASSES),
              allowed_classes=list(
                  read_class_names(cfg.YOLO.CLASSES).values()),
              show_label=True):
    detected_classes = []
    num_classes = len(classes)
    image_h, image_w, _ = image.shape
    hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]
    colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
    colors = list(
        map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
            colors))

    random.seed(0)
    random.shuffle(colors)
    random.seed(None)

    out_boxes, out_scores, out_classes, num_boxes = bboxes
    for i in range(num_boxes[0]):
        if int(out_classes[0][i]) < 0 or int(out_classes[0][i]) > num_classes:
            continue
        coor = out_boxes[0][i]
        coor[0] = int(coor[0] * image_h)
        coor[2] = int(coor[2] * image_h)
        coor[1] = int(coor[1] * image_w)
        coor[3] = int(coor[3] * image_w)

        fontScale = 0.5
        score = out_scores[0][i]
        class_ind = int(out_classes[0][i])
        class_name = classes[class_ind]

        # check if class is in allowed classes
        if class_name not in allowed_classes:
            continue
        else:

            detected_classes.append(class_name)
            bbox_color = colors[class_ind]
            bbox_thick = int(0.6 * (image_h + image_w) / 600)
            c1, c2 = (coor[1], coor[0]), (coor[3], coor[2])
            cv2.rectangle(image, c1, c2, bbox_color, bbox_thick)

            if show_label:
                bbox_mess = '%s: %.2f' % (classes[class_ind], score)
                t_size = cv2.getTextSize(bbox_mess,
                                         0,
                                         fontScale,
                                         thickness=bbox_thick // 2)[0]
                c3 = (c1[0] + t_size[0], c1[1] - t_size[1] - 3)
                cv2.rectangle(image, c1,
                              (np.float32(c3[0]), np.float32(c3[1])),
                              bbox_color, -1)  #filled

                cv2.putText(image,
                            bbox_mess, (c1[0], np.float32(c1[1] - 2)),
                            cv2.FONT_HERSHEY_SIMPLEX,
                            fontScale, (0, 0, 0),
                            bbox_thick // 2,
                            lineType=cv2.LINE_AA)
    return detected_classes, image
Esempio n. 6
0
    def test(self, sess):
        debug_dir = os.path.join(result_dir, "debug")
        if not os.path.exists(debug_dir):
            os.makedirs(debug_dir)
        img_names = self.coco.get_all_img()
        num = len(img_names)
        for img_name in tqdm(img_names):
            img = self.coco.read_img(img_name)
            height, width = img.shape[0:2]
            detections = []
            for scale in test_scales:
                new_height = int(height * scale)
                new_width = int(width * scale)
                new_center = np.array([new_height // 2, new_width // 2])

                inp_height = new_height | 127
                inp_width = new_width | 127

                images = np.zeros((1, inp_height, inp_width, 3),
                                  dtype=np.float32)
                ratios = np.zeros((1, 2), dtype=np.float32)
                borders = np.zeros((1, 4), dtype=np.float32)
                sizes = np.zeros((1, 2), dtype=np.float32)

                out_height, out_width = (inp_height + 1) // 4, (inp_width +
                                                                1) // 4
                height_ratio = out_height / inp_height
                width_ratio = out_width / inp_width

                resized_image = cv2.resize(image, (new_width, new_height))
                resized_image, border, offset = crop_image(
                    resized_image, new_center, [inp_height, inp_width])

                resized_image = resized_image / 255.
                #normalize_(resized_image, db.mean, db.std)

                images[0] = resized_image
                borders[0] = border
                sizes[0] = [int(height * scale), int(width * scale)]
                ratios[0] = [height_ratio, width_ratio]

                images = np.concatenate((images, images[:, :, ::-1, :]),
                                        axis=0)
                images = tf.convert_to_tensor(images)
                is_training = tf.convert_to_tensor(False)
                outs = self.net.corner_net(images, is_training=is_training)
                dets_tensor = self.net.decode(*outs[-6:])
                dets = sess.run(dets_tensor)

                dets = dets.reshape(2, -1, 8)
                dets[1, :, [0, 2]] = out_width - dets[1, :, [2, 0]]
                dets = dets.reshape(1, -1, 8)

                dets = rescale_dets(dets, ratios, borders, sizes)
                dets[:, :, 0:4] /= scale
                detections.append(dets)

            detections = np.concatenate(detections, axis=1)
            classes = detections[..., -1]
            classes = classes[0]
            detections = detections[0]

            # reject detections with negative scores
            keep_inds = (detections[:, 4] > -1)
            detections = detections[keep_inds]
            classes = classes[keep_inds]

            top_bboxes[image_id] = {}
            for j in range(categories):
                keep_inds = (classes == j)
                top_bboxes[image_id][j +
                                     1] = detections[keep_inds][:, 0:7].astype(
                                         np.float32)
                if merge_bbox:
                    top_bboxes[image_id][j + 1] = soft_nms_merge(
                        top_bboxes[image_id][j + 1],
                        Nt=nms_threshold,
                        method=2,
                        weight_exp=weight_exp)
                else:
                    top_bboxes[image_id][j + 1] = soft_nms(
                        top_bboxes[image_id][j + 1],
                        Nt=nms_threshold,
                        method=nms_algorithm)
                top_bboxes[image_id][j + 1] = top_bboxes[image_id][j + 1][:,
                                                                          0:5]

            scores = np.hstack([
                top_bboxes[image_id][j][:, -1]
                for j in range(1, categories + 1)
            ])
            if len(scores) > max_per_image:
                kth = len(scores) - max_per_image
                thresh = np.partition(scores, kth)[kth]
                for j in range(1, categories + 1):
                    keep_inds = (top_bboxes[image_id][j][:, -1] >= thresh)
                    top_bboxes[image_id][j] = top_bboxes[image_id][j][
                        keep_inds]

            if debug:
                image = self.coco.read_img(img_name)

                bboxes = {}
                for j in range(1, categories + 1):
                    keep_inds = (top_bboxes[image_id][j][:, -1] > 0.5)
                    cat_name = self.coco.class_name(j)
                    cat_size = cv2.getTextSize(cat_name,
                                               cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                                               2)[0]
                    color = np.random.random((3, )) * 0.6 + 0.4
                    color = color * 255
                    color = color.astype(np.int32).tolist()
                    for bbox in top_bboxes[image_id][j][keep_inds]:
                        bbox = bbox[0:4].astype(np.int32)
                        if bbox[1] - cat_size[1] - 2 < 0:
                            cv2.rectangle(image, (bbox[0], bbox[1] + 2),
                                          (bbox[0] + cat_size[0],
                                           bbox[1] + cat_size[1] + 2), color,
                                          -1)
                            cv2.putText(image,
                                        cat_name,
                                        (bbox[0], bbox[1] + cat_size[1] + 2),
                                        cv2.FONT_HERSHEY_SIMPLEX,
                                        0.5, (0, 0, 0),
                                        thickness=1)
                        else:
                            cv2.rectangle(image,
                                          (bbox[0], bbox[1] - cat_size[1] - 2),
                                          (bbox[0] + cat_size[0], bbox[1] - 2),
                                          color, -1)
                            cv2.putText(image,
                                        cat_name, (bbox[0], bbox[1] - 2),
                                        cv2.FONT_HERSHEY_SIMPLEX,
                                        0.5, (0, 0, 0),
                                        thickness=1)
                        cv2.rectangle(image, (bbox[0], bbox[1]),
                                      (bbox[2], bbox[3]), color, 2)
                debug_file = os.path.join(debug_dir, {}.format(img_name))

        # result_json = os.path.join(result_dir, "results.json")
        # detections  = db.convert_to_coco(top_bboxes)
        # with open(result_json, "w") as f:
        #     json.dump(detections, f)

        # cls_ids   = list(range(1, categories + 1))
        # image_ids = [db.image_ids(ind) for ind in db_inds]
        # db.evaluate(result_json, cls_ids, image_ids)
        return 0
	for key in bboxes:
		#print(key)
		#print(len(bboxes[key]))
		bbox = np.array(bboxes[key])

		new_boxes, new_probs = roi_helpers.non_max_suppression_fast(bbox, np.array(probs[key]), overlap_thresh = 0.3)
		for jk in range(new_boxes.shape[0]):
			(x1, y1, x2, y2) = new_boxes[jk,:]
			(real_x1, real_y1, real_x2, real_y2) = get_real_coordinates(ratio, x1, y1, x2, y2)

			cv2.rectangle(img,(real_x1, real_y1), (real_x2, real_y2), (int(class_to_color[key][0]), int(class_to_color[key][1]), int(class_to_color[key][2])),2)

			textLabel = '{}: {}'.format(key,int(100*new_probs[jk]))
			all_dets.append((key,100*new_probs[jk]))

			(retval,baseLine) = cv2.getTextSize(textLabel,cv2.FONT_HERSHEY_COMPLEX,1,1)
			textOrg = (real_x1, real_y1-0)

			cv2.rectangle(img, (textOrg[0] - 5, textOrg[1]+baseLine - 5), (textOrg[0]+retval[0] + 5, textOrg[1]-retval[1] - 5), (0, 0, 0), 2)
			cv2.rectangle(img, (textOrg[0] - 5,textOrg[1]+baseLine - 5), (textOrg[0]+retval[0] + 5, textOrg[1]-retval[1] - 5), (255, 255, 255), -1)
			cv2.putText(img, textLabel, textOrg, cv2.FONT_HERSHEY_DUPLEX, 1, (0, 0, 0), 1)

	print('Full inference = {}'.format(time.time() - st))
	print(all_dets)
	print(bboxes)
    # enable if you want to show pics
	if options.write:
           import os
           if not os.path.isdir("output"):
              os.mkdir("output")
           cv2.imwrite('./output/{}.png'.format(idx),img)
Esempio n. 8
0
def prep_display(dets_out, img, h, w, undo_transform=True, class_color=False, mask_alpha=1.0, fps_str=''):
    """
    Note: If undo_transform=False then im_h and im_w are allowed to be None.
    """
    if undo_transform:
        img_numpy = undo_image_transformation(img, w, h)
        img_gpu = torch.Tensor(img_numpy).cuda()
    else:
        img_gpu = img / 255.0
        h, w, _ = img.shape
    
    with timer.env('Postprocess'):
        save = cfg.rescore_bbox
        cfg.rescore_bbox = True
        t = postprocess(dets_out, w, h, visualize_lincomb = args.display_lincomb,
                                        crop_masks        = args.crop,
                                        score_threshold   = args.score_threshold)
        cfg.rescore_bbox = save

    with timer.env('Copy'):
        idx = t[1].argsort(0, descending=True)[:args.top_k]
        
        if cfg.eval_mask_branch:
            # Masks are drawn on the GPU, so don't copy
            masks = t[3][idx]
        classes, scores, boxes = [x[idx].cpu().numpy() for x in t[:3]]

    num_dets_to_consider = min(args.top_k, classes.shape[0])
    for j in range(num_dets_to_consider):
        if scores[j] < args.score_threshold:
            num_dets_to_consider = j
            break

    # Quick and dirty lambda for selecting the color for a particular index
    # Also keeps track of a per-gpu color cache for maximum speed
    def get_color(j, on_gpu=None):
        global color_cache
        color_idx = (classes[j] * 5 if class_color else j * 5) % len(COLORS)
        
        if on_gpu is not None and color_idx in color_cache[on_gpu]:
            return color_cache[on_gpu][color_idx]
        else:
            color = COLORS[color_idx]
            if not undo_transform:
                # The image might come in as RGB or BRG, depending
                color = (color[2], color[1], color[0])
            if on_gpu is not None:
                color = torch.Tensor(color).to(on_gpu).float() / 255.
                color_cache[on_gpu][color_idx] = color
            return color

    # First, draw the masks on the GPU where we can do it really fast
    # Beware: very fast but possibly unintelligible mask-drawing code ahead
    # I wish I had access to OpenGL or Vulkan but alas, I guess Pytorch tensor operations will have to suffice
    if args.display_masks and cfg.eval_mask_branch and num_dets_to_consider > 0:
        # After this, mask is of size [num_dets, h, w, 1]
        masks = masks[:num_dets_to_consider, :, :, None]
        
        # Prepare the RGB images for each mask given their color (size [num_dets, h, w, 1])
        colors = torch.cat([get_color(j, on_gpu=img_gpu.device.index).view(1, 1, 1, 3) for j in range(num_dets_to_consider)], dim=0)
        masks_color = masks.repeat(1, 1, 1, 3) * colors * mask_alpha

        # This is 1 everywhere except for 1-mask_alpha where the mask is
        inv_alph_masks = masks * (-mask_alpha) + 1
        
        # I did the math for this on pen and paper. This whole block should be equivalent to:
        #    for j in range(num_dets_to_consider):
        #        img_gpu = img_gpu * inv_alph_masks[j] + masks_color[j]
        masks_color_summand = masks_color[0]
        if num_dets_to_consider > 1:
            inv_alph_cumul = inv_alph_masks[:(num_dets_to_consider-1)].cumprod(dim=0)
            masks_color_cumul = masks_color[1:] * inv_alph_cumul
            masks_color_summand += masks_color_cumul.sum(dim=0)

        img_gpu = img_gpu * inv_alph_masks.prod(dim=0) + masks_color_summand
    
    if args.display_fps:
            # Draw the box for the fps on the GPU
        font_face = cv2.FONT_HERSHEY_DUPLEX
        font_scale = 0.6
        font_thickness = 1

        text_w, text_h = cv2.getTextSize(fps_str, font_face, font_scale, font_thickness)[0]

        img_gpu[0:text_h+8, 0:text_w+8] *= 0.6 # 1 - Box alpha


    # Then draw the stuff that needs to be done on the cpu
    # Note, make sure this is a uint8 tensor or opencv will not anti alias text for whatever reason
    img_numpy = (img_gpu * 255).byte().cpu().numpy()

    if args.display_fps:
        # Draw the text on the CPU
        text_pt = (4, text_h + 2)
        text_color = [255, 255, 255]

        cv2.putText(img_numpy, fps_str, text_pt, font_face, font_scale, text_color, font_thickness, cv2.LINE_AA)
    
    if num_dets_to_consider == 0:
        return img_numpy

    if args.display_text or args.display_bboxes:
        for j in reversed(range(num_dets_to_consider)):
            x1, y1, x2, y2 = boxes[j, :]
            color = get_color(j)
            score = scores[j]

            if args.display_bboxes:
                cv2.rectangle(img_numpy, (x1, y1), (x2, y2), color, 1)

            if args.display_text:
                _class = cfg.dataset.class_names[classes[j]]
                text_str = '%s: %.2f' % (_class, score) if args.display_scores else _class

                font_face = cv2.FONT_HERSHEY_DUPLEX
                font_scale = 0.6
                font_thickness = 1

                text_w, text_h = cv2.getTextSize(text_str, font_face, font_scale, font_thickness)[0]

                text_pt = (x1, y1 - 3)
                text_color = [255, 255, 255]

                cv2.rectangle(img_numpy, (x1, y1), (x1 + text_w, y1 - text_h - 4), color, -1)
                cv2.putText(img_numpy, text_str, text_pt, font_face, font_scale, text_color, font_thickness, cv2.LINE_AA)
            
    
    return img_numpy
Esempio n. 9
0
def prep_display(dets_out, img, gt, gt_masks, h, w, undo_transform=True, class_color=False):
    """
    Note: If undo_transform=False then im_h and im_w are allowed to be None.
    gt and gt_masks are also allowed to be none (until I reimplement that functionality).
    """
    if undo_transform:
        img_numpy = undo_image_transformation(img, w, h)
        img_gpu = torch.Tensor(img_numpy).cuda()
    else:
        img_gpu = img / 255.0
        h, w, _ = img.shape
    
    with timer.env('Postprocess'):
        t = postprocess(dets_out, w, h, visualize_lincomb=args.display_lincomb, crop_masks=args.crop, score_threshold=args.score_threshold)
        torch.cuda.synchronize()

    with timer.env('Copy'):
        if cfg.eval_mask_branch:
            masks = t[3][:args.top_k] # We'll need this later
        classes, scores, boxes = [x[:args.top_k].cpu().numpy() for x in t[:3]]
    
    if classes.shape[0] == 0:
        return (img_gpu * 255).byte().cpu().numpy()

    def get_color(j):
        color = COLORS[(classes[j] * 5 if class_color else j * 5) % len(COLORS)]
        if not undo_transform:
            color = (color[2], color[1], color[0])
        return color

    # Draw masks first on the gpu
    if args.display_masks and cfg.eval_mask_branch:
        for j in reversed(range(min(args.top_k, classes.shape[0]))):
            if scores[j] >= args.score_threshold:
                color = get_color(j)

                mask = masks[j, :, :, None]
                mask_color = mask @ (torch.Tensor(color).view(1, 3) / 255.0)
                mask_alpha = 0.45

                # Alpha only the region of the image that contains the mask
                img_gpu = img_gpu * (1 - mask) \
                        + img_gpu * mask * (1-mask_alpha) + mask_color * mask_alpha
        
    # Then draw the stuff that needs to be done on the cpu
    # Note, make sure this is a uint8 tensor or opencv will not anti alias text for whatever reason
    img_numpy = (img_gpu * 255).byte().cpu().numpy()
    
    if args.display_text or args.display_bboxes:
        for j in reversed(range(min(args.top_k, classes.shape[0]))):
            score = scores[j]

            if scores[j] >= args.score_threshold:
                x1, y1, x2, y2 = boxes[j, :]
                color = get_color(j)

                if args.display_bboxes:
                    cv2.rectangle(img_numpy, (x1, y1), (x2, y2), color, 1)

                if args.display_text:
                    _class = COCO_CLASSES[classes[j]]
                    text_str = '%s: %.2f' % (_class, score) if args.display_scores else _class

                    font_face = cv2.FONT_HERSHEY_DUPLEX
                    font_scale = 0.6
                    font_thickness = 1

                    text_w, text_h = cv2.getTextSize(text_str, font_face, font_scale, font_thickness)[0]

                    text_pt = (x1, y1 - 3)
                    text_color = [255, 255, 255]

                    cv2.rectangle(img_numpy, (x1, y1), (x1 + text_w, y1 - text_h - 4), color, -1)
                    cv2.putText(img_numpy, text_str, text_pt, font_face, font_scale, text_color, font_thickness, cv2.LINE_AA)
    
    return img_numpy
            heightFactor = frame.shape[0] / 300.0
            widthFactor = frame.shape[1] / 300.0
            # Scale object detection to frame
            xLeftBottom = int(widthFactor * xLeftBottom)
            yLeftBottom = int(heightFactor * yLeftBottom)
            xRightTop = int(widthFactor * xRightTop)
            yRightTop = int(heightFactor * yRightTop)
            # Draw location of object
            cv2.rectangle(frame, (xLeftBottom, yLeftBottom),
                          (xRightTop, yRightTop), (0, 255, 0))

            # Draw label and confidence of prediction in frame resized
            if class_id in classNames:
                label = classNames[class_id] + ": " + str(confidence)
                labelSize, baseLine = cv2.getTextSize(label,
                                                      cv2.FONT_HERSHEY_SIMPLEX,
                                                      0.5, 1)

                yLeftBottom = max(yLeftBottom, labelSize[1])
                cv2.rectangle(
                    frame, (xLeftBottom, yLeftBottom - labelSize[1]),
                    (xLeftBottom + labelSize[0], yLeftBottom + baseLine),
                    (255, 255, 255), cv2.FILLED)
                cv2.putText(frame, label, (xLeftBottom, yLeftBottom),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))

                print(label)  #print class and confidence

    cv2.namedWindow("frame", cv2.WINDOW_NORMAL)
    cv2.imshow("frame", frame)
    if cv2.waitKey(1) >= 0:  # Break with ESC
Esempio n. 11
0
def yolo_detect(
        pathIn='/home/haidong/Desktop/1.png',
        pathOut='/home/haidong/Desktop/test.jpg',
        #pathOut=None,
        label_path='/home/haidong/darknet/data/coco.names',
        config_path='/home/haidong/darknet/cfg/yolov3-tiny.cfg',
        weights_path='/home/haidong/darknet/yolov3-tiny_20000.weights',
        confidence_thre=0.5,
        nms_thre=0.3,
        jpg_quality=80):
    '''
    pathIn:原始图片的路径
    pathOut:结果图片的路径
    label_path:类别标签文件的路径
    config_path:模型配置文件的路径
    weights_path:模型权重文件的路径
    confidence_thre:0-1,置信度(概率/打分)阈值,即保留概率大于这个值的边界框,默认为0.5
    nms_thre:非极大值抑制的阈值,默认为0.3
    jpg_quality:设定输出图片的质量,范围为0到100,默认为80,越大质量越好
    '''

    # 加载类别标签文件
    LABELS = open(label_path).read().strip().split("\n")
    nclass = len(LABELS)

    # 为每个类别的边界框随机匹配相应颜色
    np.random.seed(42)
    COLORS = np.random.randint(0, 255, size=(nclass, 3), dtype='uint8')

    # 载入图片并获取其维度
    base_path = os.path.basename(pathIn)
    img = cv2.imread(pathIn)
    (H, W) = img.shape[:2]
    #(H,W) = img.shape[:2]
    print(1)
    # 加载模型配置和权重文件
    print('从硬盘加载YOLO......')
    net = cv2.dnn.readNetFromDarknet(config_path, weights_path)

    # 获取YOLO输出层的名字
    ln = net.getLayerNames()
    ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]

    # 将图片构建成一个blob,设置图片尺寸,然后执行一次
    # YOLO前馈网络计算,最终获取边界框和相应概率
    blob = cv2.dnn.blobFromImage(img,
                                 1 / 255.0, (416, 416),
                                 swapRB=True,
                                 crop=False)
    net.setInput(blob)
    start = time.time()
    layerOutputs = net.forward(ln)
    end = time.time()

    # 显示预测所花费时间
    print('YOLO模型花费 {:.2f} 秒来预测一张图片'.format(end - start))

    # 初始化边界框,置信度(概率)以及类别
    boxes = []
    confidences = []
    classIDs = []

    # 迭代每个输出层,总共三个
    for output in layerOutputs:
        # 迭代每个检测
        for detection in output:
            # 提取类别ID和置信度
            scores = detection[5:]
            classID = np.argmax(scores)
            confidence = scores[classID]

            # 只保留置信度大于某值的边界框
            if confidence > confidence_thre:
                # 将边界框的坐标还原至与原图片相匹配,记住YOLO返回的是
                # 边界框的中心坐标以及边界框的宽度和高度
                box = detection[0:4] * np.array([W, H, W, H])
                (centerX, centerY, width, height) = box.astype("int")

                # 计算边界框的左上角位置
                x = int(centerX - (width / 2))
                y = int(centerY - (height / 2))

                # 更新边界框,置信度(概率)以及类别
                boxes.append([x, y, int(int(width) / 2), int(height)])
                confidences.append(float(confidence))
                classIDs.append(classID)

    # 使用非极大值抑制方法抑制弱、重叠边界框
    idxs = cv2.dnn.NMSBoxes(boxes, confidences, confidence_thre, nms_thre)

    # 确保至少一个边界框
    if len(idxs) > 0:
        # 迭代每个边界框
        for i in idxs.flatten():
            # 提取边界框的坐标
            (x, y) = (boxes[i][0], boxes[i][1])
            (w, h) = (boxes[i][2], boxes[i][3])

            # 绘制边界框以及在左上角添加类别标签和置信度
            color = [int(c) for c in COLORS[classIDs[i]]]
            cv2.rectangle(img, (x, y), (x + w, y + h), color, 1)
            text = '{}: {:.3f}'.format(LABELS[classIDs[i]], confidences[i])
            (text_w,
             text_h), baseline = cv2.getTextSize(text,
                                                 cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                                                 2)
            cv2.rectangle(img, (x, y - text_h - baseline), (x + text_w, y),
                          color, -1)
            cv2.putText(img, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                        (0, 0, 0), 2)

    # 输出结果图片
    if pathOut is None:
        cv2.imwrite('with_box_' + base_path, img,
                    [int(cv2.IMWRITE_JPEG_QUALITY), jpg_quality])
    else:
        cv2.imwrite(pathOut, img, [int(cv2.IMWRITE_JPEG_QUALITY), jpg_quality])
Esempio n. 12
0
def display_instances(image, boxes, masks, class_ids, class_names,
                      scores=None, title="",
                      figsize=(16, 16), ax=None,
                      show_mask=True, show_bbox=True,
                      colors=None, captions=None):
    """
    boxes: [num_instance, (y1, x1, y2, x2, class_id)] in image coordinates.
    masks: [height, width, num_instances]
    class_ids: [num_instances]
    class_names: list of class names of the dataset
    scores: (optional) confidence scores for each box
    title: (optional) Figure title
    show_mask, show_bbox: To show masks and bounding boxes or not
    figsize: (optional) the size of the image
    colors: (optional) An array or colors to use with each object
    captions: (optional) A list of strings to use as captions for each object
    """
    # Number of instances
    N = boxes.shape[0]
    if not N:
        print("\n*** No instances to display *** \n")
    else:
        assert boxes.shape[0] == masks.shape[-1] == class_ids.shape[0]

    # If no axis is passed, create one and automatically call show()
    auto_show = False
    if not ax:
        _, ax = plt.subplots(1, figsize=figsize)
        auto_show = True

    # Generate random colors
    colors = colors or random_colors(N)

    # Show area outside image boundaries.
    height, width = image.shape[:2]
    ax.set_ylim(height + 10, -10)
    ax.set_xlim(-10, width + 10)
    ax.axis('off')
    ax.set_title(title)

    masked_image = image.astype(np.uint32).copy()
    for i in range(N):
        color = colors[i]

        # Bounding box
        if not np.any(boxes[i]):
            # Skip this instance. Has no bbox. Likely lost in image cropping.
            continue
        y1, x1, y2, x2 = boxes[i]
        if show_bbox:
            p = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=3,
                                alpha=0.7, linestyle="solid",
                                edgecolor=color, facecolor='none')
            ax.add_patch(p)

        # Label
        if not captions:
            class_id = class_ids[i]
            score = scores[i] if scores is not None else None
            label = class_names[class_id]
            x = random.randint(x1, (x1 + x2) // 2)
            caption = "{} {:.3f}".format(label, score) if score else label
            font = cv2.FONT_HERSHEY_COMPLEX_SMALL
            masked_image=cv2.putText(masked_image.astype(np.uint8),label,(x1,y1-10), font, 0.7,(255,255,255),1,cv2.LINE_AA)
            size = cv2.getTextSize(label, font, 0.7, 1)
            width = size[0][0]
            score = round(score,3)
            masked_image=cv2.putText(masked_image.astype(np.uint8),str(score),(x1+width+5,y1-10), font, 0.7,(255,255,255),1,cv2.LINE_AA)

        else:
            caption = captions[i]
        ax.text(x1, y1 + 8, caption, color='w', size=11, backgroundcolor="none")

        # Mask
        mask = masks[:, :, i]
        if show_mask:
            masked_image = apply_mask(masked_image, mask, color)
            coloro = ()
            for i in color:
                j = i*255
                coloro = coloro+(j,)

            masked_image = cv2.rectangle(masked_image.astype(np.uint8),(x1, y2),(x2,y1),coloro,3)
            masked_image=masked_image.astype(np.uint32)



        # Mask Polygon
        # Pad to ensure proper polygons for masks that touch image edges.
        padded_mask = np.zeros(
            (mask.shape[0] + 2, mask.shape[1] + 2), dtype=np.uint8)
        padded_mask[1:-1, 1:-1] = mask
        contours = find_contours(padded_mask, 0.5)
        for verts in contours:
            # Subtract the padding and flip (y, x) to (x, y)
            verts = np.fliplr(verts) - 1
            p = Polygon(verts, facecolor="none", edgecolor=color)
            ax.add_patch(p)

    print('savingimage')
    plt.imsave('savedimg.jpg',masked_image.astype(np.uint8))

    if auto_show:
        plt.show()
Esempio n. 13
0
    def detect_image(self, image):
        if self.model_image_size != (None, None):
            assert self.model_image_size[
                0] % 32 == 0, 'Multiples of 32 required'
            assert self.model_image_size[
                1] % 32 == 0, 'Multiples of 32 required'
            boxed_image = image_preporcess(
                np.copy(image), tuple(reversed(self.model_image_size)))
            image_data = boxed_image

        out_boxes, out_scores, out_classes = self.sess.run(
            [self.boxes, self.scores, self.classes],
            feed_dict={
                self.yolo_model.input: image_data,
                self.input_image_shape:
                [image.shape[0],
                 image.shape[1]],  #[image.size[1], image.size[0]],
                K.learning_phase(): 0
            })

        #print('Found {} boxes for {}'.format(len(out_boxes), 'img'))

        thickness = (image.shape[0] + image.shape[1]) // 600
        fontScale = 1
        ObjectsList = []

        for i, c in reversed(list(enumerate(out_classes))):
            predicted_class = self.class_names[c]
            box = out_boxes[i]
            score = out_scores[i]

            label = '{} {:.2f}'.format(predicted_class, score)
            #label = '{}'.format(predicted_class)
            scores = '{:.2f}'.format(score)

            top, left, bottom, right = box
            top = max(0, np.floor(top + 0.5).astype('int32'))
            left = max(0, np.floor(left + 0.5).astype('int32'))
            bottom = min(image.shape[0],
                         np.floor(bottom + 0.5).astype('int32'))
            right = min(image.shape[1], np.floor(right + 0.5).astype('int32'))

            mid_h = (bottom - top) / 2 + top
            mid_v = (right - left) / 2 + left

            # put object rectangle
            cv2.rectangle(image, (left, top), (right, bottom), self.colors[c],
                          thickness)

            # get text size
            (test_width, text_height), baseline = cv2.getTextSize(
                label, cv2.FONT_HERSHEY_SIMPLEX, thickness / self.text_size, 1)

            # put text rectangle
            cv2.rectangle(image, (left, top),
                          (left + test_width, top - text_height - baseline),
                          self.colors[c],
                          thickness=cv2.FILLED)

            # put text above rectangle
            cv2.putText(image, label, (left, top - 2),
                        cv2.FONT_HERSHEY_SIMPLEX, thickness / self.text_size,
                        (0, 0, 0), 1)

            # add everything to list
            ObjectsList.append(
                [top, left, bottom, right, mid_v, mid_h, label, scores])

        return image, ObjectsList
def draw_trackers_info(image,
                       tracks,
                       list_expr,
                       accumulation_gender=True,
                       accumulation_age=True):
    info = np.zeros(8, dtype=int)
    for track in tracks:
        if not track.is_confirmed() or track.time_since_update > 0:
            continue
        xmin, ymin, xmax, ymax = [int(x) for x in track.to_tlbr()]
        color = create_unique_color(track.track_id)

        # draw bbox
        cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)
        # track id
        label = str(track.track_id)
        text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
        cv2.rectangle(
            image, (xmin, ymin),
            (xmin + 10 + text_size[0][0], ymin + 10 + text_size[0][1]), color,
            -1)
        cv2.putText(image, label, (xmin + 5, ymin + 5 + text_size[0][1]),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)

        # draw info
        font_scale = 2
        font = cv2.FONT_HERSHEY_SIMPLEX
        thickness = 3
        # Gender
        if len(track.genders) > 0:
            if accumulation_gender:
                # return accumulate gender
                if not np.mean(track.genders) < 0.6:
                    gender = "M"
                    info[6] += 1
                else:
                    gender = "F"
                    info[7] += 1
            else:
                if not track.genders[-1] < 0.6:
                    gender = "M"
                    info[6] += 1
                else:
                    gender = "F"
                    info[7] += 1
        else:
            gender = "N/A"
        # Expr
        if track.expr in list_expr:
            idx = np.where(list_expr == str(track.expr))
            info[idx] += 1
        # Age
        if len(track.ages) > 0:
            if accumulation_age:
                age = str(int(np.mean(track.ages)))
            else:
                age = str(int(track.ages[-1]))
        else:
            age = "N/A"

        # GENDER AGE
        gen_age = gender + age
        text_size = cv2.getTextSize(gen_age, font, font_scale, thickness)
        txt_loc = (xmin, ymax + 10 + text_size[0][1])
        cv2.putText(image,
                    text=gen_age,
                    org=txt_loc,
                    fontFace=font,
                    fontScale=font_scale,
                    color=color,
                    thickness=thickness)

        # EXPR
        text_size = cv2.getTextSize(track.expr, font, font_scale, thickness)
        txt_loc = (xmin, ymax + 30 + 2 * text_size[0][1])
        cv2.putText(image,
                    text=track.expr,
                    org=txt_loc,
                    fontFace=font,
                    fontScale=font_scale,
                    color=color,
                    thickness=thickness)
    return info
Esempio n. 15
0
def plot_images(images,
                targets,
                paths=None,
                fname='images.jpg',
                names=None,
                max_size=640,
                max_subplots=16):
    tl = 3  # line thickness
    tf = max(tl - 1, 1)  # font thickness
    if os.path.isfile(fname):  # do not overwrite
        return None

    if isinstance(images, torch.Tensor):
        images = images.cpu().numpy()

    if isinstance(targets, torch.Tensor):
        targets = targets.cpu().numpy()

    # un-normalise
    if np.max(images[0]) <= 1:
        images *= 255

    bs, _, h, w = images.shape  # batch size, _, height, width
    bs = min(bs, max_subplots)  # limit plot images
    ns = np.ceil(bs**0.5)  # number of subplots (square)

    # Check if we should resize
    scale_factor = max_size / max(h, w)
    if scale_factor < 1:
        h = math.ceil(scale_factor * h)
        w = math.ceil(scale_factor * w)

    # Empty array for output
    mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8)

    # Fix class - colour map
    prop_cycle = plt.rcParams['axes.prop_cycle']
    # https://stackoverflow.com/questions/51350872/python-from-color-name-to-rgb
    hex2rgb = lambda h: tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
    color_lut = [hex2rgb(h) for h in prop_cycle.by_key()['color']]

    for i, img in enumerate(images):
        if i == max_subplots:  # if last batch has fewer images than we expect
            break

        block_x = int(w * (i // ns))
        block_y = int(h * (i % ns))

        img = img.transpose(1, 2, 0)
        if scale_factor < 1:
            img = cv2.resize(img, (w, h))

        mosaic[block_y:block_y + h, block_x:block_x + w, :] = img
        if len(targets) > 0:
            image_targets = targets[targets[:, 0] == i]
            boxes = xywh2xyxy(image_targets[:, 2:6]).T
            classes = image_targets[:, 1].astype('int')
            gt = image_targets.shape[1] == 6  # ground truth if no conf column
            conf = None if gt else image_targets[:,
                                                 6]  # check for confidence presence (gt vs pred)

            boxes[[0, 2]] *= w
            boxes[[0, 2]] += block_x
            boxes[[1, 3]] *= h
            boxes[[1, 3]] += block_y
            for j, box in enumerate(boxes.T):
                cls = int(classes[j])
                color = color_lut[cls % len(color_lut)]
                cls = names[cls] if names else cls
                if gt or conf[j] > 0.3:  # 0.3 conf thresh
                    label = '%s' % cls if gt else '%s %.1f' % (cls, conf[j])
                    plot_one_box(box,
                                 mosaic,
                                 label=label,
                                 color=color,
                                 line_thickness=tl)

        # Draw image filename labels
        if paths is not None:
            label = os.path.basename(paths[i])[:40]  # trim to 40 char
            t_size = cv2.getTextSize(label, 0, fontScale=tl / 3,
                                     thickness=tf)[0]
            cv2.putText(mosaic,
                        label, (block_x + 5, block_y + t_size[1] + 5),
                        0,
                        tl / 3, [220, 220, 220],
                        thickness=tf,
                        lineType=cv2.LINE_AA)

        # Image border
        cv2.rectangle(mosaic, (block_x, block_y), (block_x + w, block_y + h),
                      (255, 255, 255),
                      thickness=3)

    if fname is not None:
        mosaic = cv2.resize(mosaic, (int(ns * w * 0.5), int(ns * h * 0.5)),
                            interpolation=cv2.INTER_AREA)
        cv2.imwrite(fname, cv2.cvtColor(mosaic, cv2.COLOR_BGR2RGB))

    return mosaic
Esempio n. 16
0
                # is front of object outside the monitired boundary? Then write date, time and speed on image
                # and save it
                if ((x <= 2) and (direction == RIGHT_TO_LEFT)) \
                        or ((x+w >= monitored_width - 2) \
                        and (direction == LEFT_TO_RIGHT)):
                    if (last_mph > MIN_SPEED):  # save the image
                        # timestamp the image
                        cv2.putText(
                            image,
                            datetime.datetime.now().strftime(
                                "%A %d %B %Y %I:%M:%S%p"),
                            (10, image.shape[0] - 10),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 1)
                        # write the speed: first get the size of the text
                        size, base = cv2.getTextSize("%.0f mph" % last_mph,
                                                     cv2.FONT_HERSHEY_SIMPLEX,
                                                     2, 3)
                        # then center it horizontally on the image
                        cntr_x = int((IMAGEWIDTH - size[0]) / 2)
                        cv2.putText(image, "%.0f mph" % last_mph,
                                    (cntr_x, int(IMAGEHEIGHT * 0.2)),
                                    cv2.FONT_HERSHEY_SIMPLEX, 2.00,
                                    (0, 255, 0), 3)
                        # and save the image to disk
                        imageFilename = "car_at_" + datetime.datetime.now(
                        ).strftime("%Y%m%d_%H%M%S") + ".jpg"
                        # use the following image file name if you want to be able to sort the images by speed
                        #imageFilename = "car_at_%02.0f" % last_mph + "_" + datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpg"

                        cv2.imwrite(imageFilename, image)
                        if SAVE_CSV:
Esempio n. 17
0
    def test_debug(self, image, detections, debug_boxes, boxes, ratio, coco,
                   step):
        detections = detections.reshape(-1, 8)
        detections[:, 0:4:2] /= ratio[0]
        detections[:, 1:4:2] /= ratio[1]
        debug_boxes = debug_boxes.reshape(-1, 4)
        debug_boxes[:, 0:4:2] /= ratio[0]
        debug_boxes[:, 1:4:2] /= ratio[1]

        classes = detections[..., -1].astype(np.int64)

        # reject detections with negative scores
        keep_inds = (detections[:, 4] > -1)
        detections = detections[keep_inds]
        classes = classes[keep_inds]

        top_bboxes = {}
        for j in range(self.categories):
            keep_inds = (classes == j)
            top_bboxes[j + 1] = detections[keep_inds][:,
                                                      0:7].astype(np.float32)
            if self.merge_bbox:
                top_bboxes[j + 1] = soft_nms_merge(top_bboxes[j + 1],
                                                   Nt=0.5,
                                                   method=2,
                                                   weight_exp=8)
            else:
                top_bboxes[j + 1] = soft_nms(top_bboxes[j + 1],
                                             Nt=0.5,
                                             method=2)
            top_bboxes[j + 1] = top_bboxes[j + 1][:, 0:5]

        scores = np.hstack(
            [top_bboxes[j][:, -1] for j in range(1, self.categories + 1)])
        if len(scores) > self.max_per_image:
            kth = len(scores) - self.max_per_image
            thresh = np.partition(scores, kth)[kth]
            for j in range(1, self.categories + 1):
                keep_inds = (top_bboxes[j][:, -1] >= thresh)
                top_bboxes[j] = top_bboxes[j][keep_inds]
                # if len(top_bboxes[j])!=0:
                #     print(top_bboxes[j].shape)

        image = (image * 255).astype(np.uint8)

        bboxes = {}
        for j in range(1, self.categories + 1):
            #if step>10000:
            keep_inds = (top_bboxes[j][:, -1] > 0.5)
            top_bboxes[j] = top_bboxes[j][keep_inds]
            cat_name = coco.class_name(j)
            cat_size = cv2.getTextSize(cat_name, cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                                       2)[0]
            color = np.random.random((3, )) * 0.6 + 0.4
            color = color * 255
            color = color.astype(np.int32).tolist()
            for bbox in top_bboxes[j]:
                bbox = bbox[0:4].astype(np.int32)
                if bbox[1] - cat_size[1] - 2 < 0:
                    cv2.rectangle(
                        image, (bbox[0], bbox[1] + 2),
                        (bbox[0] + cat_size[0], bbox[1] + cat_size[1] + 2),
                        color, -1)
                    cv2.putText(image,
                                cat_name, (bbox[0], bbox[1] + cat_size[1] + 2),
                                cv2.FONT_HERSHEY_SIMPLEX,
                                0.5, (0, 0, 0),
                                thickness=1)
                else:
                    cv2.rectangle(image, (bbox[0], bbox[1] - cat_size[1] - 2),
                                  (bbox[0] + cat_size[0], bbox[1] - 2), color,
                                  -1)
                    cv2.putText(image,
                                cat_name, (bbox[0], bbox[1] - 2),
                                cv2.FONT_HERSHEY_SIMPLEX,
                                0.5, (0, 0, 0),
                                thickness=1)
                cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]),
                              color, 2)
            for b in boxes:
                cv2.rectangle(image, (b[0], b[1]), (b[2], b[3]), (0, 0, 255),
                              1)
        for i in range(len(debug_boxes)):
            color = np.random.random((3, )) * 0.6 + 0.4
            color = color * 255
            color = color.astype(np.int32).tolist()
            cv2.circle(image, (debug_boxes[i][0], debug_boxes[i][1]), 2, color,
                       2)
            cv2.circle(image, (debug_boxes[i][2], debug_boxes[i][3]), 2, color,
                       2)
        cv2.imwrite(os.path.join(self.debug_dir, str(step) + '.jpg'), image)
Esempio n. 18
0
    def genImage(self, imageName):
        layerGap = 80
        nodeGap = 60
        nodeRadius = 20
        padding = 40
        bgColor = (230, 230, 230)

        hiddenColor = (50, 150, 30)
        biasColor = (201, 50, 50)
        inputColor = (27, 226, 226)
        outputColor = (12, 120, 220)

        fontColor = (5, 5, 5)
        fontScale = 0.6
        fontThickness = 2

        connectionColorEnabled = (0, 0, 150)
        connectionColorDisabled = (0, 0, 100)
        connectionThickness = 2
        connectionArrowSize = 0.08

        # Make a connection dictionary for the algorithm
        connectionDict = {}
        for node in self.nodeGenes:
            connectionDict[node.index] = []
        for conn in self.connectionGenes:
            connectionDict[conn.input].append(conn.output)

        # Make a enabled connection function for drawing
        def getEnabled(connInput, connOutput):
            for i in self.connectionGenes:
                if i.input == connInput and i.output == connOutput:
                    return i.enabled
            return None

        # The algorithm to sort all nodes into layers (SUCH A PAIN)
        layers = list()
        currentLayer = list(
            i.index for i in self.getNodes("Input") + self.getNodes("Bias"))
        nextLayer = []
        outputLayer = list(i.index for i in self.getNodes("Output"))
        while len(currentLayer) > 0:
            for node in currentLayer:
                for conn in connectionDict[node]:
                    if not (conn in nextLayer) and not (conn in outputLayer):
                        nextLayer.append(conn)

                for prevLayer in layers:
                    for conn in currentLayer:
                        if conn in prevLayer:
                            prevLayer.remove(conn)

            layers.append(currentLayer.copy())
            currentLayer = nextLayer.copy()
            nextLayer = []

        layers.append(outputLayer)

        # Find the widest part in the neural net
        widestLayerLength = len(layers[0])
        for layer in layers:
            if (len(layer) > widestLayerLength):
                widestLayerLength = len(layer)

        # Calculate the image height and width that will be needed to fit the neural net
        width = padding * 2 + (widestLayerLength - 1) * nodeGap
        height = padding * 2 + (len(layers) - 1) * layerGap

        # Create a blank canvas
        img = np.array(bgColor * width * height, np.uint8)
        img = img.reshape(height, width, 3)

        # Calculate point positions
        nodePoints = {}
        for i in range(len(layers)):
            for j in range(len(layers[i])):
                x = int((width - (len(layers[i]) - 1) * nodeGap) / 2 +
                        nodeGap * j)
                y = height - padding + -i * layerGap
                nodePoints[layers[i][j]] = (x, y)

        # Draw all of the connection arrows
        for key, value in connectionDict.items():
            for i in value:
                connectionColor = connectionColorEnabled
                if not getEnabled(key, i):
                    connectionColor = connectionColorDisabled

                direction = [
                    nodePoints[i][0] - nodePoints[key][0],
                    nodePoints[i][1] - nodePoints[key][1]
                ]
                angle = np.arctan2(direction[0], direction[1])
                xOffset = int(np.sin(angle) * nodeRadius)
                yOffset = int(np.cos(angle) * nodeRadius)
                pt1 = (nodePoints[key][0] + xOffset,
                       nodePoints[key][1] + yOffset)
                pt2 = (nodePoints[i][0] - xOffset, nodePoints[i][1] - yOffset)
                cv2.arrowedLine(img, pt1, pt2, connectionColor,
                                connectionThickness, 8, 0, connectionArrowSize)

        # Plot the nodes
        for i in range(len(layers)):
            for j in range(len(layers[i])):
                nodeType = self.getNode(layers[i][j]).type
                nodeColor = hiddenColor

                if nodeType == "Input":
                    nodeColor = inputColor
                elif nodeType == "Output":
                    nodeColor = outputColor
                elif nodeType == "Bias":
                    nodeColor = biasColor

                cv2.circle(img, nodePoints[layers[i][j]], nodeRadius,
                           nodeColor, -1)

                size, _ = cv2.getTextSize(str(layers[i][j]),
                                          cv2.FONT_HERSHEY_SIMPLEX, fontScale,
                                          fontThickness)
                cv2.putText(img, str(layers[i][j]),
                            (nodePoints[layers[i][j]][0] - size[0] // 2,
                             nodePoints[layers[i][j]][1] + size[1] // 2),
                            cv2.FONT_HERSHEY_SIMPLEX, fontScale, fontColor,
                            fontThickness)

        cv2.imwrite(imageName + ".png", img)
Esempio n. 19
0
        # Calculate the frame rate
        end = time.time()
        fps = 1 / (end - start)
    else:
        fps = cap.get(cv2.CAP_PROP_FPS)

    # Get window size
    x, y, w, h = cv2.getWindowImageRect(title_window)

    # Display the title on the window
    title = title_window
    font = cv2.FONT_HERSHEY_SIMPLEX
    font_scale = 1
    (text_width, text_height) = cv2.getTextSize(title,
                                                font,
                                                fontScale=font_scale,
                                                thickness=1)[0]
    img = frame.copy()
    img = cv2.rectangle(img,
                        (int(w / 2 - text_width / 2 - 10), text_height + 45),
                        (int(w / 2 + text_width / 2 + 5), 20), (255, 255, 255),
                        cv2.FILLED)
    frame = cv2.addWeighted(img, .3, frame, .7, 0)
    frame = cv2.putText(frame, title,
                        (int(w / 2 - text_width / 2), text_height + 30), font,
                        font_scale, (20, 30, 0), 2, cv2.LINE_AA)

    # Display the frame rate on the window
    text_fps = 'FPS : ' + str(int(fps))
    font = cv2.FONT_HERSHEY_SIMPLEX
    font_scale = .8
Esempio n. 20
0
def evaluate(_):
    win_name = 'Detector'
    cv2.namedWindow(win_name)

    video = FLAGS.video

    if is_url(video):
        videoPafy = pafy.new(video)
        video = videoPafy.getbest(preftype="mp4").url

    cam = cv2.VideoCapture(video)
    if not cam.isOpened():
        raise IOError('Can\'t open "{}"'.format(FLAGS.video))

    source_h = cam.get(cv2.CAP_PROP_FRAME_HEIGHT)
    source_w = cam.get(cv2.CAP_PROP_FRAME_WIDTH)

    # print("image size = (%d, %d)" % (source_h, source_w))

    model_cls = find_class_by_name(FLAGS.model_name, [yolo])
    model = model_cls(input_shape=(source_h, source_w, 3))
    model.init()

    frame_num = 0
    start_time = time.time()
    fps = 0
    try:
        while True:
            ret, frame = cam.read()

            # cv2.imwrite("1.png", frame)

            if not ret:
                logger.info('Can\'t read video data. Potential end of stream')
                return

            predictions = model.evaluate(frame)

            for o in predictions:
                x1 = o['box']['left']
                x2 = o['box']['right']

                y1 = o['box']['top']
                y2 = o['box']['bottom']

                color = o['color']
                class_name = o['class_name']

                # print("[%s] l = %d, r = %d, t = %d, b = %d" % (class_name, x1, x2, y1, y2))

                # Draw box
                cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)

                # Draw label
                (test_width, text_height), baseline = cv2.getTextSize(
                    class_name, cv2.FONT_HERSHEY_SIMPLEX, 0.75, 1)
                cv2.rectangle(frame, (x1, y1),
                              (x1 + test_width, y1 - text_height - baseline),
                              color,
                              thickness=cv2.FILLED)
                cv2.putText(frame, class_name, (x1, y1 - baseline),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 0), 1)

            # cv2.imwrite("2.png", frame)

            # return

            end_time = time.time()
            fps = fps * 0.9 + 1 / (end_time - start_time) * 0.1
            start_time = end_time

            # Draw additional info
            frame_info = 'Frame: {0}, FPS: {1:.2f}'.format(frame_num, fps)
            cv2.putText(frame, frame_info, (10, frame.shape[0] - 10),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
            logger.info(frame_info)

            cv2.imshow(win_name, frame)

            if predictions:
                logger.info('Predictions: {}'.format(
                    format_predictions(predictions)))

            key = cv2.waitKey(1) & 0xFF

            # Exit
            if key == ord('q'):
                break

            # Take screenshot
            if key == ord('s'):
                cv2.imwrite('frame_{}.jpg'.format(time.time()), frame)

            frame_num += 1

    finally:
        cv2.destroyAllWindows()
        cam.release()
        model.close()
Esempio n. 21
0
def lane_detection(cv_bgr, x_meter, y_meter, cols, rows, fontFace, fontScale,
                   fontThickness):

    is_pass = False
    tilt1_deg = None
    tilt2_deg = None
    angle1_deg = None
    angle2_deg = None
    curve1_r = None
    curve2_r = None
    meters_from_center = None

    ########################################
    # Region Of Interest Coordinates
    ########################################
    roi_vertices = calc_roi_vertices(
        cv_bgr,
        # robocar camera demo_lane
        top_width_rate=0.28,
        top_height_position=0.45,
        bottom_width_rate=2.0,
        bottom_height_position=1)

    ########################################
    # Inverse Perspective Mapping Coordinates
    ########################################
    ipm_vertices = calc_ipm_vertices(
        cv_bgr,
        # robocar camera demo_lane
        top_width_rate=0.28,
        top_height_position=0.45,
        bottom_width_rate=2.0,
        bottom_height_position=1)

    ########################################
    # Region Of Interest
    ########################################
    cv_bgr_roi = to_roi(cv_bgr, roi_vertices)
    ########################################
    # Inverse Perspective Mapping
    ########################################
    cv_bgr_ipm = to_ipm(cv_bgr_roi, ipm_vertices)
    ########################################
    # WHITE DETECTION
    ########################################
    cv_bgr_ipm_white = to_yellow(cv_bgr_ipm)
    cv_bgr_white = to_yellow(cv_bgr)

    ########################################
    # BINARY
    ########################################
    cv_bin = to_bin(cv_bgr_ipm_white)
    cv_rgb_bin = bin_to_rgb(cv_bin)
    cv_rgb_road = None
    cv_rgb_sliding_windows = None
    cv_rgb_ellipse = None
    cv_rgb_tilt = None
    histogram = None
    meters_from_center = None
    is_sliding_window_success = False
    is_pixel_pts_success = False
    is_pixel_ellipse_success = False
    is_meter_pts_success = False
    is_meter_ellipse_success = False
    tilt_deg = 0

    ########################################
    # レーンを検出する
    ########################################
    try:
        # sliding windowsを行い、ラインを構成するピクセル座標を求める
        cv_rgb_sliding_windows, histogram, line_x, line_y = sliding_windows(
            cv_bin)
        is_sliding_window_success = True
        '''
        描画値 ピクセル座標系における計算
        '''
        # 等間隔なy座標を生成する
        plot_y = np.linspace(0, rows - 1, rows)

        # 左右センターの二次多項式と座標を求める
        line_polyfit_const, pts_line = calc_line_curve(line_x, line_y, plot_y)
        is_pixel_pts_success = True

        # 弧と傾きを描画する
        cv_rgb_ellipse, cv_rgb_tilt \
            = draw_ellipse_and_tilt(cols,rows,plot_y,pts_line,line_polyfit_const)

        # 白線画像にレーンを描画する
        cv2.polylines(cv_rgb_bin, [pts_line],
                      False, (255, 0, 0),
                      thickness=fontThickness * 20)
        # 白線道路領域をIPM逆変換する
        cv_rgb_bin = reverse_ipm(cv_rgb_bin, ipm_vertices)

        # 道路にラインを描画する
        cv_rgb_road = new_rgb(rows, cols)
        cv2.polylines(cv_rgb_road, [pts_line],
                      False, (255, 0, 0),
                      thickness=fontThickness * 20)
        # 道路をIPM変換する
        cv_rgb_road = reverse_ipm(cv_rgb_road, ipm_vertices)
        '''
        実測値 メートル座標系における計算
        '''
        # ピクセルをメートルに変換
        ym_per_pix = 1.0 * y_meter / rows
        xm_per_pix = 1.0 * x_meter / cols
        # 等間隔なy座標を生成する
        plot_ym = np.linspace(0, rows - 1, rows) * ym_per_pix
        # ラインの二次多項式と座標を求める
        line_polyfit_const, \
            _pts_line = calc_line_curve(line_x*xm_per_pix,line_y*ym_per_pix,plot_ym)
        is_meter_pts_success = True
        ########################################
        # 弧の座標と角度を求める
        # センターを上下2分割にして曲率半径と中心座標、y軸との傾き角度を計算する
        ########################################
        quarter_y = (np.max(plot_ym) - np.min(plot_ym)) / 4
        # 下半分を計算する
        y0 = np.max(plot_ym) - 2 * quarter_y
        y1 = np.max(plot_ym)
        x0,x1, \
            curve1_x,curve1_y,curve1_r, \
            rotate1_deg,angle1_deg, \
            tilt1_deg = calc_curve(y0,y1,line_polyfit_const)
        # 上半分を計算する
        quarter_y = (np.max(plot_ym) - np.min(plot_ym)) / 4
        y2 = np.min(plot_ym)
        y3 = np.max(plot_ym) - 2 * quarter_y
        x2,x3, \
            curve2_x,curve2_y,curve2_r, \
            rotate2_deg,angle2_deg, \
            tilt2_deg = calc_curve(y2,y3,line_polyfit_const)
        is_meter_ellipse_success = True

        # 画面最下部中央とライン最上部のtiltを実世界の角度で求める
        # 実世界の角度なのでx,y座標はcm座標に変換して計算する
        tilt_rad = math.atan(
            (cols * xm_per_pix / 2 - x0) / (rows * ym_per_pix - y3))
        tilt_deg = math.degrees(tilt_rad)

        # 中央線までの距離を計算する
        # 最下部の位置で計算する
        bottom_y = np.max(plot_ym)
        bottom_x = line_polyfit_const[0] * bottom_y**2 + line_polyfit_const[
            1] * bottom_y + line_polyfit_const[2]
        meters_from_center = bottom_x - (cols / 2) * xm_per_pix

        is_pass = True
    except:
        #import traceback
        #traceback.print_exc()
        pass
    finally:
        '''
        レーンを検出出来なかった時は、検出画像に空の画像を用意する
        '''
        # エラー時、もしくは描画用処理をスキップした時
        if cv_rgb_sliding_windows is None:
            cv_rgb_sliding_windows = new_rgb(rows, cols)
        if histogram is None:
            histogram = np.sum(cv_bin[int(rows / 2):, :], axis=0)
        if cv_rgb_bin is None:
            cv_rgb_bin = bin_to_rgb(cv_bin)
        if cv_rgb_ellipse is None:
            cv_rgb_ellipse = new_rgb(rows, cols)
        if cv_rgb_tilt is None:
            cv_rgb_tilt = new_rgb(rows, cols)
        pass

    frame_end_time = time.time()

    ########################################
    # ヒストグラム画像を作成する
    ########################################
    cv_rgb_histogram = draw_histogram(cols, rows, histogram, lineType)

    ########################################
    # 見た目画像を作成する
    ########################################

    # row1画面を作成する
    panel_left_row1 = new_rgb(int(rows / 3), int(cols / 3))
    cv_rgb = to_rgb(cv_bgr)

    # パネル用画像を小さくする
    cv_bgr_ipm_white = cv2.resize(cv_bgr_ipm_white,
                                  (int(cols / 3), int(rows / 3)))
    cv_rgb_histogram = cv2.resize(cv_rgb_histogram,
                                  (int(cols / 3), int(rows / 3)))
    cv_rgb_sliding_windows = cv2.resize(cv_rgb_sliding_windows,
                                        (int(cols / 3), int(rows / 3)))
    cv_rgb_bin = cv2.resize(cv_rgb_bin, (int(cols / 3), int(rows / 3)))
    cv_rgb_tilt = cv2.resize(cv_rgb_tilt, (int(cols / 3), int(rows / 3)))
    cv_rgb_ellipse = cv2.resize(cv_rgb_ellipse, (int(cols / 3), int(rows / 3)))

    if is_pass:
        '''
        左右について
        tiltx_deg: -が右、+が左
        anglex_deg: +が右、-が左
        meters_from_center: -が右にいる、+が左にいる
        handle_angle: +が右、-が左
        '''
        """ DRAW TEXT """
        sample_str = 'Sample strings'
        [(text_width, text_height),
         baseLine] = cv2.getTextSize(text=sample_str,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     thickness=fontThickness)
        x_left = int(baseLine)
        y_top = int(baseLine)

        ########################################
        # row1 leftに文字を書く
        ########################################
        if is_meter_ellipse_success:
            display_str = []
            color = (0, 255, 255)
            display_str.append("Far")
            if tilt2_deg < 0:
                display_str.append("tilt2:" + str(round(tilt2_deg, 2)) +
                                   "deg right")
            else:
                display_str.append("tilt2:" + str(round(tilt2_deg, 2)) +
                                   "deg left")
            if angle2_deg < 0:
                display_str.append("angle2:" + str(round(angle2_deg, 2)) +
                                   "deg left")
            else:
                display_str.append("angle2:" + str(round(angle2_deg, 2)) +
                                   "deg right")
            display_str.append("r2:" + str(round(curve2_r, 2)) + "m")
            end_x, end_y = draw_text(panel_left_row1,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=y_top,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

            display_str = []
            display_str.append("Near")
            color = (255, 0, 0)
            if tilt1_deg < 0:
                display_str.append("tilt1:" + str(round(tilt1_deg, 2)) +
                                   "deg right")
            else:
                display_str.append("tilt1:" + str(round(tilt1_deg, 2)) +
                                   "deg left")
            if angle1_deg < 0:
                display_str.append("angle1:" + str(round(angle1_deg, 2)) +
                                   "deg left")
            else:
                display_str.append("angle1:" + str(round(angle1_deg, 2)) +
                                   "deg right")
            end_x, end_y = draw_text(panel_left_row1,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

            display_str = []
            display_str.append("r1:" + str(round(curve1_r, 2)) + "m")
            color = (255, 0, 0)
            end_x, end_y = draw_text(panel_left_row1,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)
            """
            ####################
            # cv_rgbに矢印を描く
            ####################
            arrow_x = int(cv_rgb.shape[1]/2-35)
            arrow_y = int(cv_rgb.shape[0]/2-35)
            handle_angle = -1*tilt1_deg
            display_str = []
            display_str.append(str(round(handle_angle,2))+"deg")
            if meters_from_center >= 0:
                # 左にいる
                if np.abs(meters_from_center)*100 > 20:
                    # とても離れて左にいる:
                    if tilt2_deg > 0:
                        # 先は左に曲がる:少し左に曲がる
                        handle_angle = -1*MAX_HANDLE_ANGLE/2
                    else:
                        # 先は右に曲がる:右に全開で曲がる
                        handle_angle = 1*MAX_HANDLE_ANGLE
                elif np.abs(meters_from_center)*100 > 10:
                    if tilt2_deg > 0 :
                        # 離れて左いる、奥は左カーブ:右に少し曲がる
                        handle_angle=MAX_HANDLE_ANGLE/2
                    else:
                        # 離れて左いる、奥は右カーブ:右に全開で曲がる
                        handle_angle=MAX_HANDLE_ANGLE
            else:
                # 右にいる
                if np.abs(meters_from_center)*100 > 20:
                    # とても離れて右にいる
                    if tilt2_deg < 0:
                        # 先は右に曲がる:少し右に曲がる
                        handle_angle = 1*MAX_HANDLE_ANGLE/2
                    else:
                        # 先は左に曲がる:左に全開で曲がる
                        handle_angle = -1*MAX_HANDLE_ANGLE
                elif np.abs(meters_from_center)*100 > 10:
                    if tilt2_deg < 0 :
                        # 離れて右いる、奥は右カーブ:左に少し曲がる
                        handle_angle=-1*MAX_HANDLE_ANGLE/2
                    else:
                        # 離れて右いる、奥は左カーブ、左に全開で曲がる
                        handle_angle=-1*MAX_HANDLE_ANGLE
    
            # 動作可能な角度内に調整する
            if handle_angle > MAX_HANDLE_ANGLE:
                handle_angle = MAX_HANDLE_ANGLE
            elif handle_angle <  -1*MAX_HANDLE_ANGLE:
                handle_angle = -1*MAX_HANDLE_ANGLE
            ratio = 10*np.abs(handle_angle)/100

            if np.abs(handle_angle) <= 5:
                arrow_type = 2
                arrow_color=(0,255-(255*ratio),0)
                arrow_text_color=(0,255,0)
            elif handle_angle > 5:
                arrow_type = 1
                arrow_color=(255-(255*ratio),255-(255*ratio),255)
                arrow_text_color=(0,0,255)
            else:
                arrow_type = 3
                arrow_color=(255,255-(255*ratio),255-(255*ratio))
                arrow_text_color=(255,0,0)
    
            draw_arrow(cv_rgb,arrow_x,arrow_y,arrow_color,size=2,arrow_type=arrow_type,lineType=lineType)
            
            end_x, end_y = draw_text(cv_rgb,display_str,arrow_color,start_x=arrow_x,start_y=arrow_y-10,fontFace=fontFace, fontScale=fontScale, fontThickness=fontThickness)
            """
            """
            ####################
            # 奥のカーブ角度が大きい時、slow downを表示する
            ####################
            if np.abs(tilt2_deg) > np.abs(tilt1_deg) and np.abs(tilt2_deg) >= 15.0:
                display_str = ["slow down"]
                color = (0,0,255)
                end_x, end_y = draw_text(cv_rgb,display_str,color,start_x=arrow_x,start_y=arrow_y-30,fontFace=fontFace, fontScale=fontScale, fontThickness=fontThickness)
            """

        ########################################
        # cv_bgr_white に文字を描く
        ########################################
        display_str = ["white filter"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_bgr_ipm_white,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)

        ########################################
        # histogram に文字を描く
        ########################################
        display_str = ["histogram"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_rgb_histogram,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)

        ########################################
        # sliding windows に文字を描く
        ########################################
        display_str = ["sliding windows"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_rgb_sliding_windows,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)

        ########################################
        # cv_rgb_bin に文字を描く
        ########################################
        display_str = ["road"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_rgb_bin,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)

        ########################################
        # tilt に文字を描く
        ########################################
        display_str = ["tilts"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_rgb_tilt,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)

        if is_meter_ellipse_success:
            display_str = ["Far"]
            color = (0, 255, 255)
            if tilt2_deg < 0:
                display_str.append("tilt2:" + str(round(tilt2_deg, 2)) +
                                   "deg right")
            else:
                display_str.append("tilt2:" + str(round(tilt2_deg, 2)) +
                                   "deg left")
            end_x, end_y = draw_text(cv_rgb_tilt,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

            display_str = ["Near"]
            color = (255, 0, 0)
            if tilt1_deg < 0:
                display_str.append("tilt1:" + str(round(tilt1_deg, 2)) +
                                   "deg right")
            else:
                display_str.append("tilt1:" + str(round(tilt1_deg, 2)) +
                                   "deg left")
            end_x, end_y = draw_text(cv_rgb_tilt,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

        ########################################
        # curve に文字を描く
        ########################################
        display_str = ["curve"]
        color = (255, 255, 255)
        end_x, end_y = draw_text(cv_rgb_ellipse,
                                 display_str,
                                 color,
                                 start_x=x_left,
                                 start_y=y_top,
                                 fontFace=fontFace,
                                 fontScale=fontScale,
                                 fontThickness=fontThickness)
        if is_meter_ellipse_success:
            display_str = []
            # Far
            if angle2_deg < 0:
                display_str.append("angle2:" + str(round(angle2_deg, 2)) +
                                   "deg left")
            else:
                display_str.append("angle2:" + str(round(angle2_deg, 2)) +
                                   "deg right")
            display_str.append("r2:" + str(round(curve2_r, 2)) + "m")
            color = (0, 200, 200)
            end_x, end_y = draw_text(cv_rgb_ellipse,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

            display_str = []
            # Near
            if angle1_deg < 0:
                display_str.append("angle1:" + str(round(angle1_deg, 2)) +
                                   "deg left")
            else:
                display_str.append("angle1:" + str(round(angle1_deg, 2)) +
                                   "deg right")
            display_str.append("r1:" + str(round(curve1_r, 2)) + "m")
            color = (200, 0, 0)
            end_x, end_y = draw_text(cv_rgb_ellipse,
                                     display_str,
                                     color,
                                     start_x=x_left,
                                     start_y=end_y,
                                     fontFace=fontFace,
                                     fontScale=fontScale,
                                     fontThickness=fontThickness)

    # 画像を結合する
    panel_rgb_row2 = to_rgb(cv_bgr_ipm_white)
    panel_rgb_row2 = cv2.hconcat([panel_rgb_row2, cv_rgb_sliding_windows])
    panel_rgb_row2 = cv2.hconcat([panel_rgb_row2, cv_rgb_tilt])
    panel_rgb_row3 = cv_rgb_histogram
    panel_rgb_row3 = cv2.hconcat([panel_rgb_row3, cv_rgb_bin])
    panel_rgb_row3 = cv2.hconcat([panel_rgb_row3, cv_rgb_ellipse])
    panel_rgb_rows = cv2.vconcat([panel_rgb_row2, panel_rgb_row3])

    return is_pass, \
        to_bgr(panel_rgb_rows), to_bgr(panel_left_row1), to_bgr(cv_rgb), \
        tilt1_deg,tilt2_deg,angle1_deg,angle2_deg,curve1_r,curve2_r, \
        meters_from_center, \
        tilt_deg
Esempio n. 22
0
def overlay_on_image(frames, object_infos, LABELS):
    global map_flag  ##

    try:

        color_image = frames

        if isinstance(object_infos, type(None)):
            return color_image

        # Show images
        height = color_image.shape[0]
        width = color_image.shape[1]
        entire_pixel = height * width
        img_cp = color_image.copy()

        #show inspection result
        if map_flag == "measure_finish":  ##
            map_flag = "wait"  ##
            heat_map = cv2.applyColorMap(np.uint8(255 * map_ref),
                                         cv2.COLORMAP_JET)  ##
            heat_map = cv2.addWeighted(heat_map, 0.5, img_cp, 0.5, 2.2)  ##
            cv2.imshow("Reference", heat_map)  ##
            cv2.imwrite("Reference.jpg", heat_map)  ##
        elif map_flag == "inspection_finish":  ##
            map_flag = "wait"  ##
            heat_map = cv2.applyColorMap(
                np.uint8(255 * np.abs(map_result - map_ref)),
                cv2.COLORMAP_JET)  ##
            heat_map = cv2.addWeighted(heat_map, 0.5, img_cp, 0.5, 2.2)  ##
            cv2.imshow("Result", heat_map)  ##
            cv2.imwrite("Result.jpg", heat_map)  ##

        for (object_info, LABEL) in zip(object_infos, LABELS):

            drawing_initial_flag = True

            for box_index in range(100):
                if object_info[box_index + 1] == 0.0:
                    break
                base_index = box_index * 7
                if (not np.isfinite(object_info[base_index])
                        or not np.isfinite(object_info[base_index + 1])
                        or not np.isfinite(object_info[base_index + 2])
                        or not np.isfinite(object_info[base_index + 3])
                        or not np.isfinite(object_info[base_index + 4])
                        or not np.isfinite(object_info[base_index + 5])
                        or not np.isfinite(object_info[base_index + 6])):
                    continue

                object_info_overlay = object_info[base_index:base_index + 7]

                min_score_percent = 30  ##

                source_image_width = width
                source_image_height = height

                base_index = 0
                class_id = object_info_overlay[base_index + 1]
                percentage = int(object_info_overlay[base_index + 2] * 100)
                if (percentage <= min_score_percent):
                    continue

                box_left = int(object_info_overlay[base_index + 3] *
                               source_image_width)
                box_top = int(object_info_overlay[base_index + 4] *
                              source_image_height)
                box_right = int(object_info_overlay[base_index + 5] *
                                source_image_width)
                box_bottom = int(object_info_overlay[base_index + 6] *
                                 source_image_height)

                label_text = LABEL[int(class_id)] + " (" + str(
                    percentage) + "%)"

                box_color = (255, 128, 0)
                box_thickness = 1
                cv2.rectangle(img_cp, (box_left, box_top),
                              (box_right, box_bottom), box_color,
                              box_thickness)
                if "person" in label_text:  ##
                    label_background_color = (0, 0, 255)  ##
                    heatmap(box_left, box_top, box_right, box_bottom)  ##
                else:  ##
                    label_background_color = (125, 175, 75)  ##
                label_text_color = (0, 0, 0)  ##
                label_size = cv2.getTextSize(label_text,
                                             cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                                             1)[0]
                label_left = box_left
                label_top = box_top - label_size[1]
                if (label_top < 1):
                    label_top = 1
                label_right = label_left + label_size[0]
                label_bottom = label_top + label_size[1]
                cv2.rectangle(img_cp, (label_left - 1, label_top - 1),
                              (label_right + 1, label_bottom + 1),
                              label_background_color, -1)
                cv2.putText(img_cp, label_text, (label_left, label_bottom),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_text_color, 1)

        cv2.putText(img_cp, fps, (width - 170, 15), cv2.FONT_HERSHEY_SIMPLEX,
                    0.5, (38, 0, 255), 1, cv2.LINE_AA)
        cv2.putText(img_cp, detectfps, (width - 170, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (38, 0, 255), 1,
                    cv2.LINE_AA)
        cv2.putText(img_cp, message1, (width - 280, 45),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 38), 1,
                    cv2.LINE_AA)  ##
        cv2.putText(img_cp, message2, (width - 280, 60),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 38), 1,
                    cv2.LINE_AA)  ##
        return img_cp

    except:
        import traceback
        traceback.print_exc()
Esempio n. 23
0
            heightFactor = frame.shape[0] / 300.0
            widthFactor = frame.shape[1] / 300.0
            # Scale object detection to frame
            xLeftBottom = int(widthFactor * xLeftBottom)
            yLeftBottom = int(heightFactor * yLeftBottom)
            xRightTop = int(widthFactor * xRightTop)
            yRightTop = int(heightFactor * yRightTop)
            # Draw location of object
            cv2.rectangle(frame, (xLeftBottom, yLeftBottom),
                          (xRightTop, yRightTop), (200, 0, 0), 2)

            # Draw label and confidence of prediction in frame resized
            if class_id in classNames:
                label = classNames[class_id] + ": " + str(confidence)
                labelSize, baseLine = cv2.getTextSize(label,
                                                      cv2.FONT_HERSHEY_SIMPLEX,
                                                      0.5, 1)

                yLeftBottom = max(yLeftBottom, labelSize[1])
                cv2.rectangle(
                    frame, (xLeftBottom, yLeftBottom - labelSize[1]),
                    (xLeftBottom + labelSize[0], yLeftBottom + baseLine),
                    (200, 0, 0), cv2.FILLED)
                cv2.putText(frame, label, (xLeftBottom, yLeftBottom),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))

    curr_time = float(frame_no) / frameps
    minutes = int(curr_time / 60)
    seconds = curr_time % 60

    ## Uncomment below lines to get warning if zero peopple in frame.
def main(): 
    print("")
    print("##### YOLO OBJECT DETECTION FOR VIDEOS #####")
    print("")    
    print("Loading the model")
    print("...")
    os.environ["CUDA_VISIBLE_DEVICES"]="0"  
    device = torch.device('cuda')
    model = YOLOv1(int(args.split_size), int(args.num_boxes), int(args.num_classes)).to(device)
    num_param = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print("Amount of YOLO parameters: " + str(num_param))
    print("...")
    print("Loading model weights")
    print("...")
    weights = torch.load(args.weights)
    model.load_state_dict(weights["state_dict"])
    model.eval()
    
    # Transform is applied to the input frames
    # It resizes the image and converts it into a tensor
    transform = transforms.Compose([
        transforms.Resize((448,448), Image.NEAREST),
        transforms.ToTensor(),
        ])  
    
    print("Loading input video file")
    print("...")
    vs = cv2.VideoCapture(args.input)
    frame_width = int(vs.get(cv2.CAP_PROP_FRAME_WIDTH))
    frame_height = int(vs.get(cv2.CAP_PROP_FRAME_HEIGHT))
    # Defining the output video file
    out = cv2.VideoWriter(args.output, cv2.VideoWriter_fourcc(*"mp4v"), 30, 
            (frame_width, frame_height))
    
    # Used to scale the bounding box predictions to the original input frame
    # (448 is the dimension of the input image for the model)
    ratio_x = frame_width/448
    ratio_y = frame_height/448
    
    idx = 1 # Used to track how many frames have been already processed
    sum_fps = 0 # Used to track the average FPS at the end
    amount_frames = int(vs.get(cv2.CAP_PROP_FRAME_COUNT)) # Amount of frames
    
    while True:              
        grabbed, frame = vs.read()
        if not grabbed:
            break 
        
        # Logging the amount of processed frames 
        print("Loading frame " + str(idx) + " out of " + str(amount_frames))  
        print("Percentage done: {0:.0%}".format(idx/amount_frames)) 
        print("") 
        
        idx += 1 # Frame index
        img = Image.fromarray(frame)
        img_tensor = transform(img).unsqueeze(0).to(device)
        img = cv2.UMat(frame)

        with torch.no_grad():
            start_time = time.time()
            output = model(img_tensor) # Makes a prediction on the input frame
            curr_fps = int(1.0 / (time.time() - start_time)) # Prediction FPS
            sum_fps += curr_fps
            print("FPS for YOLO prediction: " + str(curr_fps))
            print("")

        # Extracts the class index with the highest confidence scores
        corr_class = torch.argmax(output[0,:,:,10:23], dim=2)

        for cell_h in range(output.shape[1]):
            for cell_w in range(output.shape[2]):                
                # Determines the best bounding box prediction 
                best_box = 0
                max_conf = 0
                for box in range(int(args.num_boxes)):
                    if output[0, cell_h, cell_w, box*5] > max_conf:
                        best_box = box
                        max_conf = output[0, cell_h, cell_w, box*5]
                
                # Checks if the confidence score is above the specified threshold
                if output[0, cell_h, cell_w, best_box*5] >= float(args.threshold):
                    # Extracts the box confidence score, the box coordinates and class
                    confidence_score = output[0, cell_h, cell_w, best_box*5]
                    center_box = output[0, cell_h, cell_w, best_box*5+1:best_box*5+5]
                    best_class = corr_class[cell_h, cell_w]
                    
                    # Transforms the box coordinates into pixel coordinates
                    centre_x = center_box[0]*32 + 32*cell_w
                    centre_y = center_box[1]*32 + 32*cell_h
                    width = center_box[2] * 448
                    height = center_box[3] * 448
                    
                    # Calculates the corner values of the bounding box
                    x1 = int((centre_x - width/2) * ratio_x)
                    y1 = int((centre_y - height/2) * ratio_y)
                    x2 = int((centre_x + width/2) * ratio_x)
                    y2 = int((centre_y + height/2) * ratio_y)

                    # Draws the bounding box with the corresponding class color
                    # around the object
                    cv2.rectangle(img, (x1,y1), (x2,y2), category_color[best_class], 1)
                    # Generates the background for the text, painted in the corresponding
                    # class color and the text with the class label including the 
                    # confidence score
                    labelsize = cv2.getTextSize(category_list[best_class], 
                                                cv2.FONT_HERSHEY_DUPLEX, 0.5, 1)
                    cv2.rectangle(img, (x1, y1-20), (x1+labelsize[0][0]+45,y1), 
                                  category_color[best_class], -1)
                    cv2.putText(img, category_list[best_class] + " " + 
                                str(int(confidence_score.item()*100)) + "%", (x1,y1-5), 
                                cv2.FONT_HERSHEY_DUPLEX , 0.5, (0,0,0), 1, cv2.LINE_AA)
                    # Generates a small window in the top left corner which 
                    # displays the current FPS for the prediction
                    cv2.putText(img, str(curr_fps) + "FPS", (25, 30), 
                                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
        
        out.write(img) # Stores the frame with the predictions on a new mp4 file
    print("Average FPS was: " + str(int(sum_fps / amount_frames))) 
    print("")
Esempio n. 25
0
 def get_text_size_wh(self, txt):
     ((txt_w, txt_h), _) = cv2.getTextSize(
         txt, self.font_face, self.font_scale, self.font_line_thickness
     )
     return txt_w, txt_h
def calc_visualize(func_image, objects):
    if len(objects) == 0:
        map2d = np.ones([max_y, max_x,3],dtype=np.int8)
        return func_image, map2d
    # Create Colormap
    cmap = LinearSegmentedColormap.from_list("", ["red","yellow","green"])
    # Create empty Map and combined image
    map2d = np.ones([max_y, max_x,3],dtype=np.int8)
    offset = 20
    combined = np.zeros([1080,1920+max_x+offset,3], np.uint8)
    # Transform x,y coordinates (adapt to camera angle based on calculated homography)
    objects_x_y_transformed = np.apply_along_axis(toworld, 1, objects[:,0:2])
    objects = np.column_stack((objects, objects_x_y_transformed)) #x,y,x1,y1,x2,y2,map_x,map_y
    # Get distances for transformed coordinates for all objects using KD-Tree - set distance to 255 if distance > threshold
    tree = cKDTree(objects_x_y_transformed)
    t_dst = tree.sparse_distance_matrix(tree, max_distance_detection)
    t_dst = t_dst.toarray()
    t_dst = np.array(t_dst, dtype=np.int32)
    t_dst2 = t_dst.copy()
    t_dst2[np.where(t_dst2==0)]=255
    objects = np.column_stack((objects,np.min(t_dst2,1))) #x,y,x1,y1,x2,y2,map_x,map_y,distance -> get minimum distance to another object for each object (to draw bounding boxes and points)
    # Create distance lines
    near_pairs = np.column_stack((np.argwhere(t_dst > 0),t_dst[np.nonzero(t_dst)]))
    # Get coordinates for drawing lines
    if len(near_pairs) > 0:
        near_pairs = np.apply_along_axis(get_line_coordinates, 1, near_pairs, objects)
    # Draw object bounding boxes, colored based on minimum distance to another person
    for object_ in objects:
        norm = matplotlib.colors.Normalize(vmin=0, vmax=max_distance_detection, clip=True)
        color = np.array(cmap(norm(object_[8]))[0:3])*255
        color = (color[2],color[1],color[0])
        if int(object_[8]) < 255:
            cv2.putText(func_image, str(int(object_[8])), (object_[0],object_[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2, cv2.LINE_AA)
        cv2.rectangle(func_image, (int(object_[2]),int(object_[3])), (int(object_[4]),int(object_[5])), color, 2) #x1,y1,x2,y2,color,linestrength 
        cv2.circle(map2d, (int(object_[6]),int(object_[7])), 10, color, -1)
    # Draw lines between objects, colored based on distance
    for line_ in near_pairs:
        norm = matplotlib.colors.Normalize(vmin=0, vmax=max_distance_detection, clip=True)
        color = np.array(cmap(norm(line_[8]))[0:3])*255
        color = (color[2],color[1],color[0])
        text_pt_x = int((int(line_[0])+int(line_[4])) / 2)
        text_pt_y = int((int(line_[1])+int(line_[5])) / 2)
        cv2.putText(func_image, str(int(line_[8])), (text_pt_x,text_pt_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2, cv2.LINE_AA)
        cv2.line(func_image,(int(line_[0]),int(line_[1])),(int(line_[4]),int(line_[5])),color,2)
        text_pt_x_map = int((int(line_[2])+int(line_[6])) / 2)
        text_pt_y_map = int((int(line_[3])+int(line_[7])) / 2)
        cv2.putText(map2d, str(int(line_[8])), (text_pt_x_map,text_pt_y_map), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2, cv2.LINE_AA)
        cv2.line(map2d,(int(line_[2]),int(line_[3])),(int(line_[6]),int(line_[7])),color,2)
    # Detect and draw crowds for image (based on transformed coordinates)
    crowd_data = crowd_detection(objects, max_distance_detection_crowd, 'image', min_crowd_size)
    crowd_data = crowd_suppression(crowd_data)
    for crowd in crowd_data:
        border_offset=3
        (label_width, label_height), baseline = cv2.getTextSize('Crowdsize: X', cv2.FONT_HERSHEY_DUPLEX, 0.6, 1)
        cv2.rectangle(func_image,(crowd[0],crowd[1]),(crowd[0]+label_width+10,crowd[1]-label_height-border_offset-10),(255,0,0),-1)
        cv2.putText(func_image, 'Crowdsize: {}'.format(crowd[4]), (crowd[0]+5, crowd[1]-border_offset-5), cv2.FONT_HERSHEY_DUPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)
        cv2.rectangle(func_image, (int(crowd[0]),int(crowd[1])), (int(crowd[2]),int(crowd[3])), (255,0,0), 2)
    # Detect and draw crowds for map (based on transformed coordinates)
    crowd_data = crowd_detection(objects, max_distance_detection_crowd, 'map', min_crowd_size)
    crowd_data = crowd_suppression(crowd_data)
    for crowd in crowd_data:
        border_offset=3
        (label_width, label_height), baseline = cv2.getTextSize('Crowdsize: X', cv2.FONT_HERSHEY_DUPLEX, 0.6, 1)
        cv2.rectangle(map2d,(crowd[0],crowd[1]),(crowd[0]+label_width+10,crowd[1]-label_height-border_offset-10),(255,0,0),-1)
        cv2.putText(map2d, 'Crowdsize: {}'.format(crowd[4]), (crowd[0]+5, crowd[1]-border_offset-5), cv2.FONT_HERSHEY_DUPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)
        cv2.rectangle(map2d, (int(crowd[0]),int(crowd[1])), (int(crowd[2]),int(crowd[3])), (255,255,255), 2)
    return func_image, map2d 
Esempio n. 27
0
def analyze_with_annotation(xml, csv, img, out_dir, det=False):
    #xml = Annotation file
    item_idx = 0
    fname = os.path.basename(os.path.splitext(xml)[0])
    analyze = parse_xml.parcingXml(xml)
    analyze = np.array(analyze)
    csv_arr = parse_xml.parcingCsv(csv)

    for i in range(len(analyze[0])):
        file_data = OrderedDict()
        file_data["facilities"] = []

        xmin = int(analyze[0][i])
        xmax = int(analyze[1][i])
        ymin = int(analyze[2][i])
        ymax = int(analyze[3][i])
        object_class = analyze[4][i]
        csv_copy = copy.deepcopy(csv_arr)
        csv_crop = csv_copy[ymin:ymax, xmin:xmax]
        csv_flat = csv_crop.flatten()
        csv_flat = np.round_(csv_flat, 1)
        temp_min = csv_flat.min()
        temp_max = csv_flat.max()
        temp_average = np.average(csv_flat)
        temp_average = np.round_(temp_average, 1)

        # find heating points
        csv_copy = copy.deepcopy(csv_arr)
        csv_crop = csv_copy[ymin:ymax, xmin:xmax]
        thresh = np.percentile(csv_crop, 75)
        thresh_arr = np.zeros((len(csv_crop), len(csv_crop[0])),
                              dtype=np.uint8)
        thresh_arr = np.where(csv_crop[:, :] < thresh, 0, 255)
        thresh_arr = np.array(thresh_arr, dtype=np.uint8)
        hp_contour, _ = cv2.findContours(thresh_arr, cv2.RETR_EXTERNAL,
                                         cv2.CHAIN_APPROX_NONE)

        # find reflection points
        csv_copy = copy.deepcopy(csv_arr)
        csv_crop = csv_copy[ymin:ymax, xmin:xmax]
        CRITICAL_GRAD = 0.4
        thresh = np.percentile(csv_crop, 75)
        thresh_arr = np.zeros((len(csv_crop), len(csv_crop[0])),
                              dtype=np.uint8)
        thresh_arr = np.where(csv_crop[:, :] < thresh, 0, 255)
        thresh_arr = np.array(thresh_arr, dtype=np.uint8)

        height, width = thresh_arr.shape
        suspected_points = []
        for i in range(height):
            for j in range(width):
                if thresh_arr[i][j] != 0:
                    temp = calculateMaxSubmission(i, j, csv_crop)
                    if temp > CRITICAL_GRAD:
                        suspected_points.append([j, i])

        masking_img = np.zeros((height, width, 3), dtype=np.uint8)
        for pts in suspected_points:
            xy = np.array(pts)
            cv2.circle(masking_img, (xy[0], xy[1]), 3, (255, 255, 255), -1)

        masking_img = masking_img[:, :, 0]
        masking_img = masking_img.astype(np.uint8)
        rp_contour, heirachy = cv2.findContours(masking_img, cv2.RETR_EXTERNAL,
                                                cv2.CHAIN_APPROX_NONE)

        # object_data = writeJason(xmin, ymin, xmax, ymax, temp_min, temp_max, temp_average, object_class, hp_contour, rp_contour)
        json_data = {}
        json_data["xmin"] = xmin
        json_data["ymin"] = ymin
        json_data["xmax"] = xmax
        json_data["ymax"] = ymax
        json_data["tmin"] = temp_min
        json_data["tmax"] = temp_max
        json_data["tmean"] = temp_average
        json_data["class"] = object_class
        json_data["hp_counter"] = hp_contour
        json_data["rp_counter"] = rp_contour

        #rule-base analysis
        rule = DiagnosisRule("./data/diagnosis_rule.json")
        diag_result = rule.diagnose(object_class, temp_max)
        json_data["DiagnosisCode"] = diag_result["code"]
        json_data["Cause of Failure"] = diag_result["cause"]
        json_data["Diagnosis"] = diag_result["action"]
        json_data["Over temperature"] = diag_result["Over Temperature"]
        json_data["FacilityName"] = diag_result["name"]
        json_data["Limit Temperature"] = diag_result["Limit Temperature"]
        json_data["FileName"] = fname + '.jpg'
        json_data["PointTemperature"] = json_data["tmax"]
        if diag_result["Over Temperature"] > 0:
            json_data[
                "deltaT"] = json_data["tmax"] / json_data["Limit Temperature"]
            json_data["deltaT"] = round(json_data["deltaT"], 2)

        file_data["facilities"].append(writeJson2(json_data))

        with open(os.path.join(out_dir,
                               (fname + '_{0}'.format(item_idx) + '.json')),
                  'w',
                  encoding='utf-8') as make_file:
            json.dump(file_data, make_file, indent="\t", ensure_ascii=False)

        # create image
        img_original = cv2.imread(img)
        cv2.rectangle(img_original, (xmin, ymin), (xmax, ymax), (255, 0, 0), 2)

        textLabel = object_class
        (retval, baseLine) = cv2.getTextSize(textLabel,
                                             cv2.FONT_HERSHEY_COMPLEX, 1, 1)
        textOrg = (xmin, ymin)
        cv2.rectangle(img_original,
                      (textOrg[0] - 5, textOrg[1] + baseLine - 5),
                      (textOrg[0] + retval[0] + 5, textOrg[1] - retval[1] - 5),
                      (0, 0, 0), 2)
        cv2.rectangle(img_original,
                      (textOrg[0] - 5, textOrg[1] + baseLine - 5),
                      (textOrg[0] + retval[0] + 5, textOrg[1] - retval[1] - 5),
                      (255, 255, 255), -1)
        cv2.putText(img_original, textLabel, textOrg, cv2.FONT_HERSHEY_DUPLEX,
                    1, (0, 0, 0), 1)

        png_name = fname + '_{0}'.format(item_idx) + '.png'
        cv2.imwrite(os.path.join(out_dir, png_name), img_original)

        item_idx += 1
Esempio n. 28
0
 result_lm = model_lm(torch.from_numpy(img))
 result_lm = np.array(result_lm)
 result_lm = result_lm * (0.19 * h)
 result_lm = result_lm.reshape(68, 2)
 result_lm[:, 0] += x + (0.28 * h)
 result_lm[:, 1] += y + (0.49 * w)
 _, maximum = torch.max(result.data, 1)
 pred = maximum.item()
 # displaying results based on classification
 if pred == 0:
     cv2.circle(frm, (keypoints['left_eye']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['right_eye']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['nose']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['mouth_left']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['mouth_right']), 2, yellow, 2)
     (lw, lh), bl = cv2.getTextSize("Correctly Masked", f, s, t)
     cv2.putText(frm, "Correctly Masked", ((int(
         ((w + x) - x - lw) / 2) + x), y - 10), f, s, green, t)
     cv2.rectangle(
         frm, (x, y), (x + w, y + h), green,
         2)  # green colour rectangle if mask is worn correctly
 elif pred == 1:
     cv2.circle(frm, (keypoints['left_eye']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['right_eye']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['nose']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['mouth_left']), 2, yellow, 2)
     cv2.circle(frm, (keypoints['mouth_right']), 2, yellow, 2)
     (lw, lh), bl = cv2.getTextSize("Unmasked", f, s, t)
     cv2.putText(frm, "Unmasked", ((int(
         ((w + x) - x - lw) / 2) + x), y - 10), f, s, red, t)
     cv2.rectangle(
def main():
    # load configs and set random seed
    configs = json.load(open('./configs/fer2013_config.json'))
    image_size = (configs['image_size'], configs['image_size'])

    # model = densenet121(in_channels=3, num_classes=7)
    #model = alexnet(in_channels=3, num_classes=7)
    model = resmasking_dropout1(in_channels=3, num_classes=7)
    model.cuda()

    # state = torch.load('./saved/checkpoints/densenet121_rot30_2019Nov11_14.23')
    state = torch.load('./saved/checkpoints/resmasking_dropout1__demo_part')
    #state = torch.load('./saved/checkpoints/resmasking_dropout1__demo_whole')
    #state = torch.load('./saved/checkpoints/Z_resmasking_dropout1_rot30_2019Nov30_13.32')
    model.load_state_dict(state['net'])
    model.eval()

    #vid = cv2.VideoCapture(0)
    vid = cv2.VideoCapture('video/test.mp4')
    # cv2.namedWindow('disp')
    # cv2.resizeWindow('disp', width=800)

    with torch.no_grad():
        while True:
            ret, frame = vid.read()
            if frame is None or ret is not True:
                continue

            try:
                frame = np.fliplr(frame).astype(np.uint8)
                # frame += 50
                h, w = frame.shape[:2]
                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                # gray = frame

                blob = cv2.dnn.blobFromImage(cv2.resize(frame,
                                                        (300, 300)), 1.0,
                                             (300, 300), (104.0, 177.0, 123.0))
                net.setInput(blob)
                faces = net.forward()

                for i in range(0, faces.shape[2]):
                    confidence = faces[0, 0, i, 2]
                    if confidence < 0.5:
                        continue
                    box = faces[0, 0, i, 3:7] * np.array([w, h, w, h])
                    start_x, start_y, end_x, end_y = box.astype("int")

                    #covnert to square images
                    center_x, center_y = (start_x + end_x) // 2, (start_y +
                                                                  end_y) // 2
                    square_length = ((end_x - start_x) +
                                     (end_y - start_y)) // 2 // 2

                    square_length *= 1.1

                    start_x = int(center_x - square_length)
                    start_y = int(center_y - square_length)
                    end_x = int(center_x + square_length)
                    end_y = int(center_y + square_length)

                    cv2.rectangle(frame, (start_x, start_y), (end_x, end_y),
                                  (0, 255, 255), 4)
                    # cv2.rectangle(frame , (x, y), (x + w, y + h), (179, 255, 179), 2)

                    # face = gray[y:y + h, x:x + w]
                    face = gray[start_y:end_y, start_x:end_x]

                    face = ensure_color(face)

                    face = cv2.resize(face, image_size)
                    face = transform(face).cuda()
                    face = torch.unsqueeze(face, dim=0)

                    output = torch.squeeze(model(face), 0)
                    proba = torch.softmax(output, 0)

                    # emo_idx = torch.argmax(proba, dim=0).item()
                    emo_proba, emo_idx = torch.max(proba, dim=0)
                    emo_idx = emo_idx.item()
                    emo_proba = emo_proba.item()

                    emo_label = FER_2013_EMO_DICT[emo_idx]

                    label_size, base_line = cv2.getTextSize(
                        '{}: 000'.format(emo_label), cv2.FONT_HERSHEY_SIMPLEX,
                        0.8, 2)

                    cv2.rectangle(
                        frame, (end_x, start_y + 1 - label_size[1]),
                        (end_x + label_size[0], start_y + 1 + base_line),
                        (0, 255, 255), cv2.FILLED)
                    cv2.putText(
                        frame, '{} {}'.format(emo_label, int(emo_proba * 100)),
                        (end_x, start_y + 1), cv2.FONT_HERSHEY_SIMPLEX, 0.8,
                        (150, 10, 10), 2)

                cv2.imshow('disp', frame)
                # cv2.imshow('disp', np.concatenate((gray ), axis=1))
                if cv2.waitKey(1) == ord('q'):
                    break

            except:
                continue
        cv2.destroyAllWindows()
Esempio n. 30
0
    # Load the saved prediction model and predict the digits
    pred = model.predict(ab.reshape(1, 28, 28, 1), batch_size=1)
    ans = pred.argmax()
    if ans == 0:
        ind = np.argsort(pred)
        ans = ind[1]
    if ans == 7:
        if (ww/22) < 0.5:
            ans = 1
    if ans == 1:
        if (ww/22) > 0.55:
            ans = 7
    put[(i // 9)][(i % 9)] = ans

print(put)
pfix = np.array(put)
anss = get_ans(put)
print(anss)
ww = imw.shape[0] // 9
hh = imw.shape[1] // 9
for i in range(9):
    for j in range(9):
        if pfix[i][j] != 0:
            continue
        asize = cv2.getTextSize(str(anss[i][j]),cv2.FONT_HERSHEY_SIMPLEX,1,2)[0]
        xx = (hh-asize[0])//2
        yy = (ww+asize[1])//2
        imw = cv2.putText(imw,str(anss[i][j]),(hh*j+xx,ww*i+yy),cv2.FONT_HERSHEY_SIMPLEX,1,(0,198,0),2)
cv2.imshow("read",imw)
cv2.waitKey(0)