Create app.py

app.py

@@ -0,0 +1,141 @@
+import simplejson
+import tensorflow
+import visualization_utils as vis_util
+from PIL import Image
+import numpy as np
+from PIL import Image
+import numpy as np
+import label_map_util
+import tensorflow as tf
+from matplotlib import pyplot as plt
+import time
+import cv2
+from numpy import asarray 
+import streamlit as st 
+st.title("Tag_Diciphering")
+def prediction():
+    total_time_start = time.time()
+
+
+    def loadImageIntoNumpyArray(image):
+        (im_width, im_height) = image.size
+        if image.getdata().mode == "RGBA":
+            image = image.convert('RGB')
+
+        return asarray(image).reshape((im_height, im_width, 3)).astype(np.uint8)
+
+
+    def main(image_path,model_path,model_PATH_TO_CKPT,path_to_labels):
+        image = cv2.open(image_path)
+        image_np = loadImageIntoNumpyArray(image)
+        image_np_expanded = np.expand_dims(image_np, axis=0)
+        label_map = label_map_util.load_labelmap(path_to_labels)
+    #     print("label_map------->",type(label_map))
+        categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=100, use_display_name=True)
+        category_index = label_map_util.create_category_index(categories)
+    #     print("category index-->",category_index)
+
+        detection_graph = tf.Graph()
+        with detection_graph.as_default():
+            od_graph_def = tf.compat.v1.GraphDef()
+            with tf.compat.v2.io.gfile.GFile(model_PATH_TO_CKPT, 'rb') as fid:
+                serialized_graph = fid.read()
+                od_graph_def.ParseFromString(serialized_graph)
+                tf.import_graph_def(od_graph_def, name='')
+        sess = tf.compat.v1.Session(graph=detection_graph)
+        # 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')
+        (boxes, scores, classes, num) = sess.run(
+            [detection_boxes, detection_scores, detection_classes, num_detections],
+            feed_dict={image_tensor: image_np_expanded})
+        vis_util.visualize_boxes_and_labels_on_image_array(
+            image_np,
+            np.squeeze(boxes),
+            np.squeeze(classes).astype(np.int32),
+            np.squeeze(scores),
+            category_index,
+            use_normalized_coordinates=True,
+            line_thickness=8,
+            min_score_thresh=0.1)
+        #%matplotlib inline
+        from matplotlib import pyplot as plt
+    #     print("boxes:",boxes)
+    #     print("class:",classes)
+        objects = []
+        threshold = 0.5
+    #     print("category:",category_index)
+        boxes = boxes[0]
+        for index, value in enumerate(classes[0]):
+            object_dict = {}
+            if scores[0, index] > threshold:
+                object_dict["class"] = (category_index.get(value)).get('name')
+                object_dict["score"] = round(scores[0, index] * 100,2)
+                box = tuple(boxes[index].tolist())
+                ymin, xmin, ymax, xmax= box
+                im_width,im_height = 360,360
+                left, right, top, bottom = (xmin * im_width, xmax * im_width, 
+                                  ymin * im_height, ymax * im_height)
+                object_dict["box"] = (int(left), int(right), int(top), int(bottom))
+                objects.append(object_dict)
+
+        image_orignal = Image.open(image_path)
+        image_np_orignal = loadImageIntoNumpyArray(image_orignal)
+
+
+        fig, ax = plt.subplots(1,2)
+
+        fig.suptitle('Tag Deciphering')
+
+        ax[0].imshow(image_np_orignal,aspect='auto');
+        ax[1].imshow(image_np,aspect='auto');
+
+
+        return objects
+    images = ["img1.jpg","img2.jpg","img3.jpg","img4.jpg"]
+    with st.sidebar:
+        st.write("choose an image")
+        st.image(images)
+    file = st.file_uploader('Upload an Image',type=(["jpeg","jpg","png"]))
+
+    if file is None:
+        st.write("Please upload an image file")
+    else:
+        image= Image.open(file)
+        st.image(image,use_column_width = True)
+        
+    image_path = file
+    model_path = "//inference"
+    model_PATH_TO_CKPT = "frozen_inference_graph.pb"
+    path_to_labels = "tf_label_map.pbtxt"
+
+    result = main(image_path,model_path,model_PATH_TO_CKPT,path_to_labels)
+    st.write(result)
+    # print("result-",result)
+    # list_to_be_sorted= [{'class': 'Y', 'score': 99.97, 'box': (157, 191, 269, 288)}, {'class': '6', 'score': 99.93, 'box': (158, 191, 247, 267)}, {'class': '9', 'score': 99.88, 'box': (156, 190, 179, 196)}, {'class': '4', 'score': 99.8, 'box': (156, 189, 198, 219)}, {'class': '1', 'score': 99.65, 'box': (157, 189, 222, 244)}, {'class': 'F', 'score': 63.4, 'box': (155, 185, 157, 175)}]
+    newlist = sorted(result, key=lambda k: k['box'][3],reverse=False)
+
+    text =''
+    for each in newlist:
+        if(each['score']>65):
+            text += each['class']
+    # print("text:",text)
+    if(text!=""):
+        text = text.replace("yellowTag", "") 
+        result = text
+    else:
+        result = "No Vertical Tag Detected"
+    response = {"predictions": [result]}
+    total_time_end = time.time()
+    print("total time : ",round((total_time_end-total_time_start),2))
+    st.write(str(simplejson.dumps(response)))
+
+prediction()