Beispiel #1
0
def obj_detect(image):

    input_size = cfg['input_size']
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    original_image = image
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image), [input_size, input_size])
    image_data = image_data[np.newaxis, ...]

    # model infer
    pred_sbbox, pred_mbbox, pred_lbbox = obj_detect_infer.infer(image_data)

    # post process get final bboxes
    num_classes = cfg['num_classes']
    pred_bbox = np.concatenate([np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                                np.reshape(pred_lbbox, (-1, 5 + num_classes))], axis=0)
    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size, input_size, 0.5)
    bboxes = utils.nms(bboxes, 0.45, method='nms')

    res = {}
    objs = []
    for bbox in bboxes:
        objs.append({'x1':bbox[0], 'y1':bbox[1], 'x2':bbox[2], 'y2':bbox[3], 'confidence':bbox[4], 'class':bbox[5]})
    res['objs'] = objs 

    return res
Beispiel #2
0
    def predict(self, image):
        org_image = np.copy(image)
        org_h, org_w, _ = org_image.shape

        # 将 image 转成需要的格式和 大小
        image_data = utils.image_preporcess(image,
                                            [self.input_size, self.input_size])
        # 给图片加一个维度,加在最前面
        image_data = image_data[np.newaxis, ...]

        pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
            [self.pred_sbbox, self.pred_mbbox, self.pred_lbbox],
            feed_dict={
                self.input_data: image_data,
                self.trainable: False
            })

        # concatenate() 多个数组的拼接
        # reshape(data, newshape)
        # newshape=(-1, nums) 表示生成一个 (rows, cols)的形状,cols = nums, rows的值根据cols的值计算
        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + self.num_classes))
        ],
                                   axis=0)

        # 筛选出有效,在范围内的框
        bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w),
                                         self.input_size, self.score_threshold)

        # 筛选出一个最合适的框
        bboxes = utils.nms(bboxes, self.iou_threshold)

        return bboxes
Beispiel #3
0
def find_bbox(path, confidence_score=0.7, iou=0.5):
    bbox_list = []
    images = []
    model = tf.keras.models.load_model('SavedModel/YOLOv3_model',
                                       compile=False)

    INPUT_SIZE = cfg.TEST.INPUT_SIZE
    SCORE_THRESHOLD = confidence_score
    IOU_THRESHOLD = iou

    for filename in os.listdir(path):
        full_path_image = path + '/' + filename
        images.append(full_path_image)

    for path_to_image in images:
        image = cv2.imread(path_to_image)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image_size = image.shape[:2]
        image_data = utils.image_preporcess(np.copy(image),
                                            [INPUT_SIZE, INPUT_SIZE])
        image_data = image_data[np.newaxis, ...].astype(
            np.float32)  # (1, width, height, 3)

        pred_bbox = model.predict(image_data)
        pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
        pred_bbox = tf.concat(pred_bbox, axis=0)
        bboxes = utils.postprocess_boxes(pred_bbox, image_size, INPUT_SIZE,
                                         SCORE_THRESHOLD)
        bboxes = utils.nms(bboxes, IOU_THRESHOLD, method='nms')
        bboxes.append(path_to_image)
        bbox_list.append(bboxes)

    return bbox_list
Beispiel #4
0
    def predict(self, image):

        org_image = np.copy(image)
        org_h, org_w, _ = org_image.shape

        image_data = utils.image_preporcess(image,
                                            [self.input_size, self.input_size])
        image_data = image_data[np.newaxis, ...]

        pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
            [self.pred_sbbox, self.pred_mbbox, self.pred_lbbox],
            feed_dict={
                self.input_data: image_data,
                self.trainable: False
            })

        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + self.num_classes))
        ],
                                   axis=0)
        bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w),
                                         self.input_size, self.score_threshold)
        bboxes = utils.nms(bboxes, self.iou_threshold)

        return bboxes
Beispiel #5
0
def test_image(image_path, model_path):
    input_size = 416
    original_image      = cv2.imread(image_path)
    original_image      = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]

    image_data = utils.image_preporcess(np.copy(original_image), [input_size, input_size])
    image_data = image_data[np.newaxis, ...].astype(np.float32)

    model = yolov3.build_for_test()
    # 加载tf model:model.load_weights(model_path);加载darknet model: utils.load_weights(model, model_path)
    utils.load_weights(model, model_path)
    model.summary()
    start_time = time.time()
    pred_bbox = model.predict(image_data)
    print('pred_bbox>>>>>>>>>>>>>>>>>', pred_bbox)
    end_time = time.time()
    print("time: %.2f ms" %(1000*(end_time-start_time)))

    pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
    pred_bbox = tf.concat(pred_bbox, axis=0)
    # 将416×416下的bbox坐标转换为原图上的坐标并删除部分无效box
    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size, input_size, 0.3)
    bboxes = utils.nms(bboxes, 0.45, method='nms')
    # 构建原图和bbox画出坐标框
    image = utils.draw_bbox(original_image, bboxes)
    image = Image.fromarray(image)
    image.show()
    def predict(self, image):

        org_image = np.copy(image)
        org_h, org_w, _ = org_image.shape
        image_data = utils.image_preporcess(image,
                                            [self.input_size, self.input_size])

        image_data = image_data[np.newaxis, ...]
        options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
        run_metadata = tf.RunMetadata()
        pred_sbbox, pred_mbbox, pred_lbbox, conv_sbbox, conv_mbbox, conv_lbbox = self.sess.run(
            [
                self.pred_sbbox, self.pred_mbbox, self.pred_lbbox,
                self.conv_sbbox, self.conv_mbbox, self.conv_lbbox
            ],
            feed_dict={
                self.input_data: image_data,
                self.trainable: False
            },
            options=options,
            run_metadata=run_metadata)

        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 9 + self.num_classes)),
            np.reshape(pred_mbbox, (-1, 9 + self.num_classes)),
            np.reshape(pred_lbbox, (-1, 9 + self.num_classes))
        ],
                                   axis=0)

        bboxes1 = utils.postprocess_boxes(pred_bbox, (org_h, org_w),
                                          self.input_size,
                                          self.score_threshold)
        bboxes = utils.nms(bboxes1, self.iou_threshold)

        return bboxes
Beispiel #7
0
    def predict(self, image_path):
        original_image = cv2.imread(image_path)
        original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
        original_image_size = original_image.shape[:2]
        image_data = utils.image_preporcess(np.copy(original_image),
                                            [self.input_size, self.input_size])
        image_data = image_data[np.newaxis, ...]

        with tf.Session(graph=self.graph) as sess:
            pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
                [
                    self.return_tensors[1], self.return_tensors[2],
                    self.return_tensors[3]
                ],
                feed_dict={self.return_tensors[0]: image_data})

        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + self.num_classes))
        ],
                                   axis=0)

        bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                         self.input_size, 0.3)
        bboxes = utils.nms(bboxes, 0.45, method='nms')
        image, label = utils.draw_bbox(original_image, bboxes)
        # image = Image.fromarray(image)
        # print(image)
        cv2.imwrite('static/images/test.jpg', image)
        # image.show()
        return label
def batch_bboxes(model, frames):

    all_image_data = [None] * len(frames)
    sizes = [None] * len(frames)
    bbbb = [[], []]

    for i, frame in enumerate(frames):
        #move frame to GPU
        all_image_data[i] = frame_to_gpu(frame)
        sizes[i] = frame.shape[:2]

    stacked = tf.stack(all_image_data, axis=1)

    trimmed = tf.squeeze(stacked)
    # print(trimmed.shape)

    # dataset = tf.data.Dataset.from_tensor_slices(stacked)
    # dataset = dataset.batch(2)
    # for im_data in dataset.as_numpy_iterator():
    pred_bbox = model.predict(trimmed)
    print('aww yeah')

    pred_bbox = utils.postprocess_bbbox(pred_bbox, ANCHORS, STRIDES, XYSCALE)

    all_bboxes, probs, classes, image_nums = utils.postprocess_boxes(
        pred_bbox, sizes[0], INPUT_SIZE, 0.25)  #.25
    bboxes = utils.filter_people(all_bboxes, probs, classes)
    bboxes = utils.nms(bboxes, 0.213, method='nms')
    bboxes = np.array(bboxes)

    # bboxes2 = utils.nms(bboxes2, 0.213, method='nms')
    # bboxes2 = np.array(bboxes2)

    print('frame1')
Beispiel #9
0
def predicate(original_image, pb_file):
    if pb_file == None:
        pb_file = DEFAULT_PB
    
    return_elements = ["input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0", "pred_lbbox/concat_2:0"]
    num_classes     = 66
    input_size      = 608
    graph           = tf.Graph()

    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image), [input_size, input_size])
    image_data = image_data[np.newaxis, ...]

    return_tensors = utils.read_pb_return_tensors(graph, pb_file, return_elements)


    with tf.compat.v1.Session(graph=graph) as sess:
        pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
            [return_tensors[1], return_tensors[2], return_tensors[3]],
                    feed_dict={ return_tensors[0]: image_data})

    pred_bbox = np.concatenate([np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                                np.reshape(pred_lbbox, (-1, 5 + num_classes))], axis=0)

    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size, input_size, 0.3)
    bboxes = utils.nms(bboxes, 0.45, method='nms')
    return bboxes, original_image
Beispiel #10
0
    def predict(self, input_rgb,input_lwir):

        org_image_rgb = np.copy(input_rgb)
        org_image_lwir = np.copy(input_lwir)       
        org_h, org_w, _ = org_image_rgb.shape

        img_rgb,img_lwir = utils.image_preporcess(org_image_rgb,org_image_lwir, [self.input_size, self.input_size])
        img_rgb = img_rgb[np.newaxis, ...]
        img_lwir = img_lwir[np.newaxis, ...]
        
        pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
            [self.pred_sbbox, self.pred_mbbox, self.pred_lbbox],
            feed_dict={
                self.input_rgb:   img_rgb,
                self.input_lwir:   img_lwir,
                self.trainable: False
            }
        )

        pred_bbox = np.concatenate([np.reshape(pred_sbbox, (-1, 5 + self.num_classes)),
                                    np.reshape(pred_mbbox, (-1, 5 + self.num_classes)),
                                    np.reshape(pred_lbbox, (-1, 5 + self.num_classes))], axis=0)
        bboxes = utils.postprocess_boxes(pred_bbox, (org_h, org_w), self.input_size, self.score_threshold)
        bboxes = utils.nms(bboxes, self.iou_threshold)

        return bboxes
    def calculate(self, frame):
        start = int(round(time.time() * 1000))
        # Image to be processed
        original_image = frame
        # Read class names
        class_names = {}
        with open(cfg.YOLO.CLASSES, 'r') as data:
            for ID, name in enumerate(data):
                class_names[ID] = name.strip('\n')

        original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
        original_image_size = original_image.shape[:2]

        image_data = utils.image_preporcess(np.copy(original_image),
                                            [self.input_size, self.input_size])
        image_data = image_data[np.newaxis, ...].astype(np.float32)

        pred_bbox = self.model.predict(image_data)
        pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
        pred_bbox = tf.concat(pred_bbox, axis=0)

        bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                         self.input_size, 0.3)
        bboxes = utils.nms(bboxes, 0.45, method='nms')
        # We have our objects detected and boxed, lets move the class name into a list
        objects_detected = []
        for x0, y0, x1, y1, prob, class_id in bboxes:
            objects_detected.append(class_names[class_id])
        # Lets show the user a nice picture - should be erased in production
        #image = utils.draw_bbox(original_image, bboxes)
        #image = Image.fromarray(image)
        #image.show()
        exec_time = int(round(time.time() * 1000)) - start
        print(f"Objects Detected: {objects_detected}")
        return objects_detected, exec_time
Beispiel #12
0
            def detect_img(fim, start_h, start_w, fpredict_bboxes):
                img_size = fim.shape[:2]
                image_data = utils.image_preporcess(np.copy(fim),
                                                    [input_size, input_size])
                image_data = image_data[np.newaxis, ...]

                pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                    [return_tensors[1], return_tensors[2], return_tensors[3]],
                    feed_dict={return_tensors[0]: image_data})
                pred_bbox = np.concatenate([
                    np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                    np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                    np.reshape(pred_lbbox, (-1, 5 + num_classes))
                ],
                                           axis=0)

                bboxes = utils.postprocess_boxes(pred_bbox, img_size,
                                                 input_size, score_thresh)
                bboxes = utils.nms(bboxes, iou_type, iou_thresh, method='nms')

                for i, bbox in enumerate(bboxes):
                    # bboxes: [x_min, y_min, x_max, y_max, probability, cls_id] format coordinates
                    coor = np.array(bbox[:4], dtype=np.int32)
                    bbox[0] = int(start_w + coor[0])
                    bbox[1] = int(start_h + coor[1])
                    bbox[2] = int(start_w + coor[2])
                    bbox[3] = int(start_h + coor[3])
                    fpredict_bboxes.append(bbox)
def alone_bbox(image_path, save_path):
    class_list = ["bench", "roadblock", "babycar", "wheelchair"]
    return_elements = [
        "input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0",
        "pred_lbbox/concat_2:0"
    ]
    input_size = cfg.TEST.INPUT_SIZE
    graph = tf.Graph()
    save_file_name = osp.basename(image_path).split('.')[0] + '.txt'
    original_image = cv2.imread(image_path)
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...]

    with open(osp.join(save_path, save_file_name), 'a') as fp:
        name_dict_list = []
        bboxes_list = []
        for newlabel in class_list:
            pb_file = "./yolov3_{}.pb".format(newlabel)
            name_dict = utils.read_class_names(
                "./data/classes/{}.names".format(newlabel))
            name_dict_list.append(name_dict)
            num_classes = len(name_dict)

            return_tensors = utils.read_pb_return_tensors(
                graph, pb_file, return_elements)

            with tf.Session(graph=graph) as sess:
                pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                    [return_tensors[1], return_tensors[2], return_tensors[3]],
                    feed_dict={return_tensors[0]: image_data})

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                np.reshape(pred_lbbox, (-1, 5 + num_classes))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                             input_size, 0.9)
            bboxes = utils.nms(bboxes, 0.90, method='nms')
            bboxes_list.append(bboxes)
            o = str(' ' + str(0))
            for bbox in bboxes:
                min_x, min_y, max_x, max_y = [
                    str(int(bbox[i])) for i in range(4)
                ]
                label_name = name_dict[int(bbox[5])]
                fp.writelines(label_name + o + o + o + ' ' + min_x + ' ' +
                              min_y + ' ' + max_x + ' ' + max_y + o + o + o +
                              o + o + o + o)
                fp.writelines('\n')
        # for i,bboxes_ in enumerate(bboxes_list):
        #     image = utils.draw_bbox(original_image, bboxes_, name_dict_list[i])
        # image = Image.fromarray(image)
        # image.show()
    return bboxes_list, name_dict_list
def predict(image_path):

    original_image = cv2.imread(image_path)  # 读取图片
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...]

    return_tensors = utils.read_pb_return_tensors(graph, pb_file,
                                                  return_elements)

    with tf.Session(graph=graph) as sess:
        pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
            [return_tensors[1], return_tensors[2], return_tensors[3]],
            feed_dict={return_tensors[0]: image_data})

    pred_bbox = np.concatenate([
        np.reshape(pred_sbbox, (-1, 5 + num_classes)),
        np.reshape(pred_mbbox, (-1, 5 + num_classes)),
        np.reshape(pred_lbbox, (-1, 5 + num_classes))
    ],
                               axis=0)

    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                     input_size, 0.35)
    bboxes = utils.nms(bboxes, 0.45, method='nms')
    image = utils.draw_bbox(original_image, bboxes)

    image = Image.fromarray(image)
    image.show()
    image.save(output_path)
def coco_bbox(image_path, save_path, return_tensorsm, graph):
    t1 = time.time()
    # return_elements     = ["input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0", "pred_lbbox/concat_2:0"]
    input_size = cfg.TEST.INPUT_SIZE
    # graph               = tf.Graph()
    save_file_name = osp.basename(image_path).split('.jp')[0] + '.txt'
    original_image = cv2.imread(image_path)
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...]
    # pb_file             = cfg.TEST.PB_FILE
    name_dict = utils.read_class_names(cfg.TEST.CLASSES)
    num_classes = len(name_dict)
    choose_classes = cfg.TEST.CHOOSE_CLASSES

    with open(osp.join(save_path, save_file_name), 'w') as fp:
        # return_tensors = utils.read_pb_return_tensors(graph, pb_file, return_elements)

        with tf.compat.v1.Session(graph=graph) as sess:
            pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                [return_tensors[1], return_tensors[2], return_tensors[3]],
                feed_dict={return_tensors[0]: image_data})
        # t2 = time.time()
        # print("time2: ", t2 - t1)

        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + num_classes))
        ],
                                   axis=0)

        bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                         input_size, 0.45)
        bboxes = utils.nms(bboxes, 0.35, method='nms')
        o = str(' ' + str(0))
        # with open(osp.join(save_path, save_file_name), 'w') as fp:
        for bbox in bboxes:
            min_x, min_y, max_x, max_y = [str(int(bbox[i])) for i in range(4)]
            score = str(round(bbox[4], 2))
            label_name = name_dict[int(bbox[5])]
            if label_name == 'person':
                label_name_choose = 'Pedestrian'
            elif label_name == 'bicycle' or label_name == 'motorbike':
                label_name_choose = 'Cyclist'
            elif label_name == 'car' or label_name == 'bus' or label_name == 'truck':
                label_name_choose = 'Car'
            else:
                label_name_choose = 'DontCare'
            if label_name in choose_classes:
                fp.writelines(label_name + o + o + o + ' ' + min_x + ' ' +
                              min_y + ' ' + max_x + ' ' + max_y + o + o + o +
                              o + o + o + o + " " + score)
                fp.writelines('\n')
        # image = utils.draw_bbox(original_image, bboxes,name_dict)
        # image = Image.fromarray(image)
        # image.show()
    return original_image, bboxes, name_dict
def predict_logo_boxes(image_path, input_size, num_classes, original_image, return_tensors, sess):
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image), [input_size, input_size])
    image_data = image_data[np.newaxis, ...]
    pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
        [return_tensors[1], return_tensors[2], return_tensors[3]],
        feed_dict={return_tensors[0]: image_data})
    pred_yolo_bbox = np.concatenate([np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                                     np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                                     np.reshape(pred_lbbox, (-1, 5 + num_classes))], axis=0)
    post_yolo_boxes = utils.postprocess_boxes(pred_yolo_bbox, original_image_size, input_size, 0.1)
    post_yolo_boxes = utils.nms(post_yolo_boxes, 0.2, method='nms')
    post_yolo_boxes = ipm.logo_filter(post_yolo_boxes)
    ocr_boxes = ipm.text_detection(image_path)

    # cost_match_matrix refers to the distance pairs between the yolo boxes and ocr boxes
    cost_match_matrix = ipm.cost_calculating(post_yolo_boxes, ocr_boxes)

    row_ind, col_ind = linear_sum_assignment(cost_match_matrix)
    ocr_boxes = [ocr_boxes[t] for t in col_ind]
    yolo_boxes = [post_yolo_boxes[t] for t in row_ind]

    distance = cost_match_matrix[row_ind, col_ind]
    mask = [d < 100 for d in distance]

    yolo_boxes = np.array(yolo_boxes)
    ocr_boxes = np.array(ocr_boxes)

    yolo_boxes = yolo_boxes[mask]
    yolo_boxes = yolo_boxes.tolist()

    ocr_boxes = ocr_boxes[mask]
    ocr_boxes = ocr_boxes.tolist()

    return ocr_boxes, post_yolo_boxes
def on_run(image):
    image_data = utils.image_preporcess(np.copy(image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...].astype(np.float32)

    pred_bbox = model.predict(image_data)

    # sys.stdout.write(f"[yolo_detect] pred_bbox {pred_bbox}")
    # sys.stdout.write(f"[yolo_detect] pred_bbox[0].shape {pred_bbox[0].shape}")
    # sys.stdout.write(f"[yolo_detect] anchors {anchors}")
    # sys.stdout.flush()

    if model_name == "yolov3":
        pred_bbox = utils.postprocess_bbbox(pred_bbox, anchors, STRIDES)
    else:
        pred_bbox = utils.postprocess_bbbox(pred_bbox, anchors, STRIDES,
                                            XYSCALE)

    bboxes = utils.postprocess_boxes(pred_bbox, image.shape[:-1], input_size,
                                     conf_threshold)
    bboxes = utils.nms(bboxes, iou_threshold, method='nms')

    # bboxes[[xmin, ymin, xmax, ymax, score, class]]
    # sys.stdout.write(f"[yolov4 detect] bboxes {bboxes}")
    # sys.stdout.flush()

    return {'bboxes': np.array(bboxes)}
Beispiel #18
0
def process(image_path, targetFolder, sess, return_tensors):
    head, tail = os.path.split(image_path)
    localFileName = tail

    original_image = cv2.imread(image_path)
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]
    image_data = utils.image_preporcess(np.copy(original_image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...]

    pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
        [return_tensors[1], return_tensors[2], return_tensors[3]],
        feed_dict={return_tensors[0]: image_data})

    pred_bbox = np.concatenate([
        np.reshape(pred_sbbox, (-1, 5 + num_classes)),
        np.reshape(pred_mbbox, (-1, 5 + num_classes)),
        np.reshape(pred_lbbox, (-1, 5 + num_classes))
    ],
                               axis=0)

    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                     input_size, score_threshold)
    bboxes = utils.nms(bboxes, 0.45, method='nms')
    image = utils.draw_bbox(original_image, bboxes)
    image = Image.fromarray(image)

    exportName = "out_" + localFileName

    filepath = targetFolder + "/" + exportName
    image.save(filepath)
Beispiel #19
0
    def predict(self, images):

        org_h = [0 for i in range(self.batch_size)]
        org_w = [0 for i in range(self.batch_size)]
        for i in range(self.batch_size):
            org_h[i], org_w[i], _ = images[i].shape

        image_data = utils.images_preporcess(
            images, [self.input_size, self.input_size])

        start = time.time()
        pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
            [self.pred_sbbox, self.pred_mbbox, self.pred_lbbox],
            feed_dict={
                self.input_data: image_data,
            })
        end = time.time()
        print("inference time exclude postprocess is: ", (end - start) * 1000)
        batch_bboxes = []
        for idx in range(self.batch_size):
            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox[idx], (-1, 5 + self.num_classes)),
                np.reshape(pred_mbbox[idx], (-1, 5 + self.num_classes)),
                np.reshape(pred_lbbox[idx], (-1, 5 + self.num_classes))
            ],
                                       axis=0)
            bboxes = utils.postprocess_boxes(pred_bbox,
                                             (org_h[idx], org_w[idx]),
                                             self.input_size,
                                             self.score_threshold)
            batch_bboxes.append(utils.nms(bboxes, self.iou_threshold))
        end_ = time.time()
        print("inference time include postprocess is: ", (end_ - start) * 1000)
        return batch_bboxes, (end - start)
Beispiel #20
0
def detect_images(model,
                  image_path,
                  box=None,
                  output_path="",
                  id=0,
                  write_file=True,
                  show=False):
    """Object classification of the given image.

    Run the yolo model on the given image. With post process including nms. 
    Save the output image to file or show the image if specified. 

    Args:
        model: The yolo model to be used. 
        image_path: path to the image.
        box: bounding box coordinates. Should be a list like: [x1, y1, x2, y2].
        output_path: path to write the output image. 
        id: index of bounding box for a given frame.
        show: whether to show the image for display.
    """
    original_image = cv2.imread(image_path)
    if box:
        original_image = original_image[box[1]:box[3], box[0]:box[2]]
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]

    image_data, old_image_size, new_image_size = utils.image_preprocess(
        np.copy(original_image))
    image_data = image_data[np.newaxis, ...].astype(np.float32)

    # pred_bbox = model.predict(image_data)
    pred_bbox = model.predict_on_batch(image_data)
    pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
    pred_bbox = tf.concat(pred_bbox, axis=0)
    bboxes = utils.postprocess_boxes(pred_bbox, old_image_size, new_image_size,
                                     0.3)
    bboxes = utils.nms(bboxes, 0.45, method='nms')

    image = utils.draw_bbox(original_image, bboxes)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    if id:
        i = output_path.rfind('.')
        output_path = output_path[:i] + '_' + str(id) + output_path[i:]
    if output_path != '' and write_file:
        i = output_path.rfind('/')
        output_directory = output_path[:i]
        if not os.path.exists(output_directory):
            os.makedirs(output_directory)
        cv2.imwrite(output_path, image)

    if show:
        # Show the image
        cv2.imshow("predicted image", image)
        # Load and hold the image
        cv2.waitKey(0)
        # To close the window after the required kill value was provided
        cv2.destroyAllWindows()
Beispiel #21
0
def mul_image(watch_dir="./docs/images", output_path='./output'):
    imageDir = os.path.abspath(watch_dir)
    imageList = glob.glob(os.path.join(imageDir, '*.jpg'))
    # print(imageList)

    graph = tf.Graph()
    pb_file = "./yolov3_coco_v3.pb"
    return_elements = [
        "input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0",
        "pred_lbbox/concat_2:0"
    ]
    return_tensors = utils.read_pb_return_tensors(graph, pb_file,
                                                  return_elements)

    with tf.Session(graph=graph) as sess:

        for item in imageList:
            image_path = item
            # print('item',item)
            end = "/"
            name = item[item.rfind(end):]
            # print(name)
            num_classes = 80
            input_size = 608
            out = output_path + name

            original_image = cv2.imread(image_path)
            # original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
            original_image_size = original_image.shape[:2]
            image_data = utils.image_preporcess(np.copy(original_image),
                                                [input_size, input_size])
            image_data = image_data[np.newaxis, ...]

            pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                [return_tensors[1], return_tensors[2], return_tensors[3]],
                feed_dict={return_tensors[0]: image_data})

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                np.reshape(pred_lbbox, (-1, 5 + num_classes))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                             input_size, 0.45)

            # print('bboxes:',bboxes)
            # bboxes: [[301.13088989 118.44700623 346.95623779 172.39486694   0.97461057   0]...]

            bboxes = utils.nms(bboxes, 0.45, method='nms')
            # print('bboxes:',bboxes)
            # bboxes: [array([105.31238556,  54.51167679, 282.53552246, 147.27146912, 0.99279714,   0.        ])]

            image = utils.draw_bbox(original_image, bboxes)

            cv2.imwrite(out, image)
Beispiel #22
0
def vehicle_detection(image):
    protocol = ProtocolType.from_str('http')

    input_name = 'input/input_data'
    sboxes = 'pred_sbbox/concat_2'
    mboxes = 'pred_mbbox/concat_2'
    lboxes = 'pred_lbbox/concat_2'
    model_name = 'vehicle-detector'

    ctx = InferContext('localhost:8000', protocol, model_name, -1, False)

    ori_size = image.shape[:2]
    image_preprocess = utils.image_preporcess(image, [416, 416])

    image_data = []
    image_data.append(image_preprocess)
    result = []
    image_idx = 0
    request_ids = []
    batch_size = 4
    last_request = False

    input_batch = []
    while not last_request:
        input_batch = []
        for idx in range(batch_size):
            input_batch.append(image_data[image_idx])
            image_idx = (image_idx + 1) % len(image_data)
            if image_idx == 0:
                last_request = True
                batch_size = len(input_batch)
                break
        request_ids.append(
            ctx.async_run({input_name: input_batch}, {
                sboxes: (InferContext.ResultFormat.RAW),
                mboxes: (InferContext.ResultFormat.RAW),
                lboxes: (InferContext.ResultFormat.RAW)
            }, batch_size))

    raw_results = []
    num_classes = 80
    # # For async, retrieve results according to the send order
    for request_id in request_ids:
        raw_results.append(ctx.get_async_run_results(request_id, True))
    for ix in range(len(raw_results)):
        pred_sbbox, pred_mbbox, pred_lbbox = raw_results[ix][
            'pred_sbbox/concat_2'], raw_results[ix][
                'pred_mbbox/concat_2'], raw_results[ix]['pred_lbbox/concat_2']
        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + num_classes))
        ],
                                   axis=0)
        bboxes = utils.postprocess_boxes(pred_bbox, ori_size, 416, 0.3)
        bboxes = utils.nms(bboxes, 0.45, method='nms')
        return bboxes
Beispiel #23
0
def video_without_saving():

    classes = utils.read_class_names(cfg.YOLO.CLASSES)
    num_classes = len(classes)
    return_elements = [
        "input/input_data:0", "pred_sbbox/concat_2:0", "pred_mbbox/concat_2:0",
        "pred_lbbox/concat_2:0"
    ]
    pb_file = "./yolov3_coco.pb"
    video_path = "docs/images/racoon.mp4"
    video_path = 0

    input_size = 416
    graph = tf.Graph()
    return_tensors = utils.read_pb_return_tensors(graph, pb_file,
                                                  return_elements)

    with tf.Session(graph=graph) as sess:
        vid = cv2.VideoCapture(video_path)
        while True:
            return_value, frame = vid.read()
            if return_value:
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                image = Image.fromarray(frame)
            else:
                raise ValueError("No image!")
            frame_size = frame.shape[:2]
            image_data = utils.image_preporcess(np.copy(frame),
                                                [input_size, input_size])
            image_data = image_data[np.newaxis, ...]
            prev_time = time.time()

            pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                [return_tensors[1], return_tensors[2], return_tensors[3]],
                feed_dict={return_tensors[0]: image_data})

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                np.reshape(pred_lbbox, (-1, 5 + num_classes))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
                                             0.3)
            bboxes = utils.nms(bboxes, 0.45, method='nms')
            image = utils.draw_bbox(frame, bboxes)

            curr_time = time.time()
            exec_time = curr_time - prev_time
            result = np.asarray(image)
            info = "time: %.2f ms" % (1000 * exec_time)
            cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE)
            result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
            cv2.imshow("result", result)
            if cv2.waitKey(1) & 0xFF == ord('q'): break
Beispiel #24
0
def gen():
    for i in range(5):
        count = 0
        cap = cv2.VideoCapture("full_video.mp4")
        start_frame_number = 1000
        cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame_number)
        while True:
            cap.set(cv2.CAP_PROP_POS_MSEC, (count * 125))
            ret, frame = cap.read()
            count += 1
            if not ret:
                break

            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame)

            frame_size = frame.shape[:2]
            image_data = utils.image_preporcess(np.copy(frame),
                                                [input_size, input_size])
            image_data = image_data[np.newaxis, ...]
            image_data = image_data.astype(np.float32)
            prev_time = time.time()
            request.inputs['input'].CopyFrom(
                tf.contrib.util.make_tensor_proto(
                    image_data, shape=[1, input_size, input_size, 3]))
            result_future = stub.Predict.future(request, 10.25)
            pred_sbbox = np.asarray(
                result_future.result().outputs['pred_sbbox'].float_val)
            pred_mbbox = np.asarray(
                result_future.result().outputs['pred_mbbox'].float_val)
            pred_lbbox = np.asarray(
                result_future.result().outputs['pred_lbbox'].float_val)

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                np.reshape(pred_lbbox, (-1, 5 + num_classes))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
                                             0.3)
            bboxes = utils.nms(bboxes, 0.45, method='nms')
            image = utils.draw_bbox(frame, bboxes)

            curr_time = time.time()
            exec_time = curr_time - prev_time
            print(exec_time)
            result = np.asarray(image)
            frame = cv2.cvtColor(result, cv2.COLOR_RGB2BGR)
            #result = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
            #format should be bgr
            ret, jpeg = cv2.imencode('.jpg', frame)
            frame = jpeg.tobytes()
            yield (b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
Beispiel #25
0
def show(pred_bbox):
    pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
    pred_bbox = tf.concat(pred_bbox, axis=0)
    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                     input_size, 0.3)
    bboxes = utils.nms(bboxes, 0.45, method='nms')
    image = utils.draw_bbox(original_image, bboxes, show_label=True)
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    cv2.imshow('sample', image)
    cv2.waitKey(0)
Beispiel #26
0
def detection(vid):
    with tf.Session(graph=graph) as sess:

        return_value, frame = vid.read()
        if return_value:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame)
        else:
            raise ValueError("No image!")

        frame_size = frame.shape[:2]
        image_data = utils.image_preporcess(np.copy(frame),
                                            [input_size, input_size])
        image_data = image_data[np.newaxis, ...]
        prev_time = time.time()

        pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
            [return_tensors[1], return_tensors[2], return_tensors[3]],
            feed_dict={return_tensors[0]: image_data})

        pred_bbox = np.concatenate([
            np.reshape(pred_sbbox, (-1, 5 + num_classes)),
            np.reshape(pred_mbbox, (-1, 5 + num_classes)),
            np.reshape(pred_lbbox, (-1, 5 + num_classes))
        ],
                                   axis=0)

        bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
                                         0.3)
        bboxes = utils.nms(bboxes, 0.45, method='nms')
        image, detected = utils.draw_bbox(frame, bboxes)

        detected = np.asarray(detected)

        # print("------- frame i ---------")

        class_count = []

        for i in range(len(obj_classes)):  # 80
            obj_count = 0
            for j in range(len(detected)):
                if int(detected[j][5]) == i: obj_count += 1

            class_count = np.append(class_count, obj_count)

        curr_time = time.time()
        exec_time = curr_time - prev_time
        result = np.asarray(image)
        info = "time: %.2f ms" % (1000 * exec_time)
        # cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE)
        result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)

    return result, class_count
def get_object(video_url, threshold=0.45):
    input_layer = tf.keras.layers.Input([input_size, input_size, 3])
    feature_maps = YOLOv3(input_layer)

    bbox_tensors = []
    for i, fm in enumerate(feature_maps):
        bbox_tensor = decode(fm, i)
        bbox_tensors.append(bbox_tensor)

    model = tf.keras.Model(input_layer, bbox_tensors)
    utils.load_weights(model, "yolov3_union_10000.weights")
    model.summary()

    vid = cv2.VideoCapture(video_url)
    while True:
        return_value, frame = vid.read()
        if return_value:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        else:
            return "No image"
        frame_size = frame.shape[:2]
        image_data = utils.image_preporcess(np.copy(frame),
                                            [input_size, input_size])
        image_data = image_data[np.newaxis, ...].astype(np.float32)

        prev_time = time.time()
        pred_bbox = model.predict_on_batch(image_data)
        curr_time = time.time()
        exec_time = curr_time - prev_time

        pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
        pred_bbox = tf.concat(pred_bbox, axis=0)
        bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
                                         0.3)
        bboxes = utils.nms(bboxes, threshold, method='nms')
        image = utils.draw_bbox(frame, bboxes)

        result = np.asarray(image)
        info = "time: %.2f ms" % (1000 * exec_time)
        cv2.putText(result,
                    text=info,
                    org=(50, 70),
                    fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                    fontScale=1,
                    color=(255, 0, 0),
                    thickness=2)

        result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)

        retval, buffer = cv2.imencode(".jpeg", image)
        yield ((b'--frame\r\n'
                b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() +
                b'\r\n'))
Beispiel #28
0
def export_yolo_video(video_path, output_path):
    vid = cv2.VideoCapture(video_path)
    out = cv2.VideoWriter(
        str(Path(output_path,
                 Path(video_path).stem + '_output.mp4')),
        cv2.VideoWriter_fourcc(*'mp4v'),
        float(vid.get(cv2.CAP_PROP_FPS)),
        (round(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
         round(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))),
    )
    outputs = []
    print(Path(output_path, Path(video_path).stem + '_output.mp4'))
    print(Path(output_path, Path(video_path).stem + '_output.npz'))
    max_frames = vid.get(cv2.CAP_PROP_FRAME_COUNT)
    with tf.Session(graph=graph) as sess:
        for _ in trange(int(max_frames)):
            return_value, frame = vid.read()
            if return_value:
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            else:
                raise ValueError("No image!")
            frame_size = frame.shape[:2]
            image_data = utils.image_preporcess(np.copy(frame),
                                                [input_size, input_size])
            image_data = image_data[np.newaxis, ...]

            pred_sbbox, pred_mbbox, pred_lbbox = sess.run(
                [return_tensors[1], return_tensors[2], return_tensors[3]],
                feed_dict={return_tensors[0]: image_data})

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + num_classes)),
                np.reshape(pred_mbbox, (-1, 5 + num_classes)),
                np.reshape(pred_lbbox, (-1, 5 + num_classes))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, frame_size, input_size,
                                             0.3)
            bboxes = utils.nms(bboxes, 0.45, method='nms')
            outputs.append(bboxes)

            image = utils.draw_bbox(frame, bboxes)

            result = np.asarray(image)
            result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
            out.write(result)

    vid.release()
    out.release()
    np.savez(str(Path(output_path,
                      Path(video_path).stem + '_output.npz')), outputs)
Beispiel #29
0
    def do_video(self):
        vid = cv2.VideoCapture(self.video_path)
        while True:
            # frame 是 RGB 颜色空间
            return_value, frame = vid.read()
            if return_value:
                # utils.image_preporcess 这个方法里面有 cv2.COLOR_BGR2RGB 方法
                # 如果自己写的模型,可以调一下,也许不需要这里
                frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
                pass
            else:
                raise ValueError("No image!")
                pass

            frame_size = frame.shape[:2]
            # 之前训练的时候,转了一次颜色空间
            image_data = utils.image_preporcess(
                np.copy(frame), [self.input_size, self.input_size])
            image_data = image_data[np.newaxis, ...]

            pred_start_time = datetime.now()

            pred_sbbox, pred_mbbox, pred_lbbox = self.sess.run(
                [
                    self.return_tensors[1], self.return_tensors[2],
                    self.return_tensors[3]
                ],
                feed_dict={self.return_tensors[0]: image_data})

            pred_bbox = np.concatenate([
                np.reshape(pred_sbbox, (-1, 5 + self.class_name_len)),
                np.reshape(pred_mbbox, (-1, 5 + self.class_name_len)),
                np.reshape(pred_lbbox, (-1, 5 + self.class_name_len))
            ],
                                       axis=0)

            bboxes = utils.postprocess_boxes(pred_bbox, frame_size,
                                             self.input_size, 0.3)
            bboxes = utils.nms(bboxes, 0.45, method='nms')
            image = utils.draw_bbox(frame, bboxes)

            pred_end_time = datetime.now()
            print("一帧耗时: {}".format(pred_end_time - pred_start_time))

            cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE)
            result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
            cv2.imshow("result", result)
            # 退出按键
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
            pass
        pass
Beispiel #30
0
def detect(image_path):
    #original_image=Image.open(BytesIO(original_image)).convert("RGBA")
    original_image = cv2.imread(
        image_path
    )  #you can and should replace this line to receive the image directly (not from a file)
    #original_image = base64.b64decode(dec_image)
    # Read class names
    class_names = {}
    with open(cfg.YOLO.CLASSES, 'r') as data:
        for ID, name in enumerate(data):
            class_names[ID] = name.strip('\n')

    # Setup tensorflow, keras and YOLOv3
    input_size = 416
    input_layer = tf.keras.layers.Input([input_size, input_size, 3])
    feature_maps = YOLOv3(input_layer)

    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    original_image_size = original_image.shape[:2]

    image_data = utils.image_preporcess(np.copy(original_image),
                                        [input_size, input_size])
    image_data = image_data[np.newaxis, ...].astype(np.float32)

    bbox_tensors = []
    for i, fm in enumerate(feature_maps):
        bbox_tensor = decode(fm, i)
        bbox_tensors.append(bbox_tensor)

    model = tf.keras.Model(input_layer, bbox_tensors)
    load_weights(model, "./yolov3.weights")

    pred_bbox = model.predict(image_data)
    pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]
    pred_bbox = tf.concat(pred_bbox, axis=0)

    bboxes = utils.postprocess_boxes(pred_bbox, original_image_size,
                                     input_size, 0.3)
    bboxes = utils.nms(bboxes, 0.45, method='nms')

    # We have our objects detected and boxed, lets move the class name into a list
    objects_detected = []
    for x0, y0, x1, y1, prob, class_id in bboxes:
        objects_detected.append(class_names[class_id])

    # Lets show the user a nice picture - should be erased in production
    #image = utils.draw_bbox(original_image, bboxes)
    #image = Image.fromarray(image)
    #image.show()
    return objects_detected