Object_detection_image.py

product_details={
    1: {
    'id': 1,
    'name': 'Britania-toast-large',
    'price': 50
},

2: {
    'id': 2,
    'name': 'Britania-toast-med',
    'price': 30
},

3: {
    'id': 3,
    'name': 'Britania-toast-small',
    'price': 20
},

4: {
    'id': 4,
    'name': 'coke-1.5l',
    'price': 120
},

5: {
    'id': 5,
    # 'name': 'coke-700ml',
    'name': 'coke-bottle-700ml',
    'price': 99
},

6: {
    'id': 6,
    'name': 'coke-bottle-2l',
    'price': 160
},

7: {
    'id': 7,
    'name': 'coke-bottle-300ml',
    'price': 60
},

8: {
    'id': 8,
    'name': 'coke-bottle-700ml',
    'price': 99
},

9: {
    'id': 9,
    'name': 'coke-can',
    'price': 30
},

10: {
    'id': 10,
    'name': 'coke-can-diet',
    'price': 40
},

11: {
    'id': 11,
    'name': 'coke-can-energy',
    'price': 40
},

12: {
    'id': 12,
    'name': 'coke-can-espresso',
    'price': 50
},

13: {
    'id': 13,
    'name': 'coke-can-orange',
    'price': 30
},

14: {
    'id': 14,
    'name': 'coke-can-zero',
    'price': 35
},

15: {
    'id': 15,
    'name': 'coke-diet/zero-bottle-700ml',
    'price': 105
},

16: {
    'id': 16,
    'name': 'coke-glass-bottle',
    'price': 10
},

17: {
    'id': 17,
    'name': 'colgate-Plax',
    'price': 49
},

18: {
    'id': 18,
    'name': 'colgate-family',
    'price': 130
},

19: {
    'id': 19,
    'name': 'colgate-medium',
    'price': 79
},

20: {
    'id': 20,
    'name': 'colgate-small',
    'price': 39
},

21: {
    'id': 21,
    'name': 'colgate-total-150gm',
    'price': 150
},

22: {
    'id': 22,
    'name': 'gooday-large',
    'price': 40
},

23: {
    'id': 23,
    'name': 'gooday-medium',
    'price': 30
},

24: {
    'id': 24,
    'name': 'gooday-medium-choco',
    'price': 35
},

25: {
    'id': 25,
    'name': 'gooday-small',
    'price': 10
},

26: {
    'id': 26,
    'name': 'gooday-small-butter',
    'price': 5
},

27: {
    'id': 27,
    'name': 'gooday-small-choco',
    'price': 10
},

28: {
    'id': 28,
    'name': 'lays-large',
    'price': 40
},

29: {
    'id': 29,
    'name': 'lays-med',
    'price': 20
},

30: {
    'id': 30,
    'name': 'lays-small',
    'price': 10
},

31: {
    'id': 31,
    'name': 'lays-small-5',
    'price': 5
},

32: {
    'id': 32,
    'name': 'maggi-family',
    'price':40
},

33: {
    'id': 33,
    'name': 'maggi-small',
    'price':10
},

34: {
    'id': 34,
    'name': 'nescafe-caffe',
    'price':2
},

35: {
    'id': 35,
    'name': 'nescafe-can',
    'price':391
},

36: {
    'id': 36,
    'name': 'nescafe-cappe',
    'price':70
},

37: {
    'id': 37,
    'name': 'nescafe-cappe-big',
    'price':160
},

38: {
    'id': 38,
    'name': 'nescafe-cappe-med',
    'price':99
},

39: {
    'id': 39,
    'name': 'nescafe-classic/gold-big',
    'price':396
},

40: {
    'id': 40,
    'name': 'nescafe-classic/gold-med',
    'price':339
},

41: {
    'id': 41,
    'name': 'nescafe-classic/gold-small',
    'price':299
},

42: {
    'id': 42,
    'name': 'nescafe-dolce',
    'price':90
},

43: {
    'id': 43,
    'name': 'nescafe-dolce-big',
    'price':60
},

44: {
    'id': 44,
    'name': 'nescafe-mug',
    'price':50
},

45: {
    'id': 45,
    'name': 'pepsi-can',
    'price':30
},

46: {
    'id': 46,
    'name': 'toothbrush',
    'price':25
}
}

# Import packages
import os
import cv2
import numpy as np
import sys
import tensorflow as tf

# Import utilites
from utils import label_map_util
from utils import visualization_utils as vis_util

detection_graph=''
label_map=''
categories=''
category_index=''
sess=''

def load_tensorflow_to_memory(PATH_TO_IMAGE):
    ######## Image Object Detection Using Tensorflow-trained Classifier #########
    #
    # Author: Team StrawHats
    # Date: 5/10/19
    # Description:
    # This program uses a TensorFlow-trained classifier to perform object detection.
    # It loads the classifier uses it to perform object detection on an image.

    ## Some of the code is copied from Google's example at
    ## https://github.com/tensorflow/models/blob/master/research/object_detection/object_detection_tutorial.ipynb

    ## but we changed it to make it more understandable, as per our use case.


    # Name of the directory containing the object detection module we're using
    MODEL_NAME = 'inference_graph'

    # Grab path to current working directory
    CWD_PATH = os.getcwd()

    # Path to frozen detection graph .pb file, which contains the model that is used
    # for object detection.
    PATH_TO_CKPT = os.path.join(CWD_PATH,MODEL_NAME,'frozen_inference_graph9_10_17712.pb')

    # Path to label map file
    PATH_TO_LABELS = os.path.join(CWD_PATH,'training','labelmap_collab8_10.pbtxt')

    # Path to image
    # PATH_TO_IMAGE = os.path.join(CWD_PATH,IMAGE_NAME)

    # Number of classes the object detector can identify
    NUM_CLASSES = 46

    # Load the label map.
    # Label maps map indices to category names, so that when our convolution
    # network predicts `5`, we know that this corresponds to `king`.
    # Here we use internal utility functions, but anything that returns a
    # dictionary mapping integers to appropriate string labels would be fine
    global category_index
    global label_map
    global categories
    label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
    categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
    category_index = label_map_util.create_category_index(categories)

    global detection_graph
    # Load the Tensorflow model into memory.
    detection_graph = tf.Graph()
    with detection_graph.as_default():
        od_graph_def = tf.GraphDef()
        with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
            serialized_graph = fid.read()
            od_graph_def.ParseFromString(serialized_graph)
            tf.import_graph_def(od_graph_def, name='')

        global sess
        sess = tf.Session(graph=detection_graph)
    return perform_product_detection(PATH_TO_IMAGE)

def perform_product_detection(PATH_TO_IMAGE):

    # Define input and output tensors (i.e. data) for the object detection classifier

    # Input tensor is the image
    image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')

    # Output tensors are the detection boxes, scores, and classes
    # Each box represents a part of the image where a particular object was detected
    detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')

    # Each score represents level of confidence for each of the objects.
    # The score is shown on the result image, together with the class label.
    detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
    detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')

    # Number of objects detected
    num_detections = detection_graph.get_tensor_by_name('num_detections:0')

    # Load image using OpenCV and
    # expand image dimensions to have shape: [1, None, None, 3]
    # i.e. a single-column array, where each item in the column has the pixel RGB value
    image = cv2.imread(PATH_TO_IMAGE)
    image_expanded = np.expand_dims(image, axis=0)

    # Perform the actual detection by running the model with the image as input
    (boxes, scores, classes, num) = sess.run(
        [detection_boxes, detection_scores, detection_classes, num_detections],
        feed_dict={image_tensor: image_expanded})


    import csv
    final_score = np.squeeze(scores)
    count = 0
    for i in range(100):
        if scores is None or final_score[i] > 0.6:
                count = count + 1
    print('Detected Product :',count)
    printcount =0;

    if count!=0:
        for i in classes[0]:
            if(printcount == count):
                break
            printcount = printcount +1
            with open('product_list.csv', mode='a',newline='') as product_file:
                lister =[]
                product_writer = csv.writer(product_file)
                lister.append(category_index[i]['id'])
                product_writer.writerow(lister)
        return [1,count]
    else:
        return [PATH_TO_IMAGE,count]