Esempio n. 1
0
def predict_image():
    image_path = "/home/chenwei/HDD/Project/datasets/object_detection/VOCdevkit/VOC2007/JPEGImages/000066.jpg"
    image = cv2.imread(image_path)
    image_size = image.shape[:2]
    input_shape = [model_params['input_height'], model_params['input_width']]
    image_data = preporcess(image, input_shape)
    image_data = image_data[np.newaxis, ...]

    input = tf.placeholder(shape=[1, input_shape[0], input_shape[1], 3],
                           dtype=tf.float32)

    model = Network(len(model_params['classes']),
                    model_params['anchors'],
                    is_train=False)
    with tf.variable_scope('yolov3'):
        logits = model.build_network(input)
        output = model.inference(logits)

    checkpoints = "/home/chenwei/HDD/Project/YOLOv3/weights/yolov3.ckpt"
    saver = tf.train.Saver()
    with tf.Session() as sess:
        saver.restore(sess, checkpoints)
        bboxes, obj_probs, class_probs = sess.run(
            output, feed_dict={input: image_data})

    bboxes, scores, class_max_index = postprocess(bboxes,
                                                  obj_probs,
                                                  class_probs,
                                                  image_shape=image_size,
                                                  input_shape=input_shape)

    resize_ratio = min(input_shape[1] / image_size[1],
                       input_shape[0] / image_size[0])
    dw = (input_shape[1] - resize_ratio * image_size[1]) / 2
    dh = (input_shape[0] - resize_ratio * image_size[0]) / 2
    bboxes[:, [0, 2]] = (bboxes[:, [0, 2]] - dw) / resize_ratio
    bboxes[:, [1, 3]] = (bboxes[:, [1, 3]] - dh) / resize_ratio

    img_detection = visualization(image, bboxes, scores, class_max_index,
                                  model_params["classes"])
    cv2.imshow("result", img_detection)
    cv2.waitKey(0)
Esempio n. 2
0
            ToTensor()
        ]),
    ),
                             batch_size=1,
                             shuffle=False,
                             num_workers=0)

    useful_list = []
    repeat_list = []
    with torch.no_grad():
        for i_batch, sample_batched in enumerate(data_loader, 1):
            im1_data, im1_info, homo12, im2_data, im2_info, homo21, im1_raw, im2_raw = parse_batch(
                sample_batched, device)

            # (angle, class_id, octave, pt, response, size)
            scale1, kp1, des1, _, _, _ = model.inference(
                im1_data, im1_info, im1_raw)
            scale2, kp2, des2, _, _, _ = model.inference(
                im2_data, im2_info, im2_raw)

            kp1c = np.array([[kp[2].cpu().numpy(), kp[1].cpu().numpy()]
                             for kp in kp1])
            kp2c = np.array([[kp[2].cpu().numpy(), kp[1].cpu().numpy()]
                             for kp in kp2])
            # import pdb;pdb.set_trace()
            im1_data, im1_info, homo12, im2_data, im2_info, homo21, im1_raw, im2_raw = parse_batch_np(
                sample_batched, mean, std)
            repeatable, useful = caluseful(kp1c, kp2c, homo12, im2_data)
            useful_list.append(useful), repeat_list.append(repeatable)

    usefuls = np.array(useful_list)
    repeats = np.array(repeat_list)