app.py

from datetime import date
import tensorflow as tf
import pandas as pd
import gradio as gr
import numpy as np
import cv2 as cv2

def shapeModel():
  labels=["Octagon","Triangle","Circle Prohibitory","Circle","Rhombus"]
  json_file = open('./model/model1.json', 'r')
  loaded_model_json = json_file.read()
  json_file.close()
  model = tf.keras.models.model_from_json(loaded_model_json)
  model.load_weights("./model/model1.h5")
  return [model,labels]

def recognitionModel():
  json_file = open('./recognition_model/model.json', 'r')
  loaded_model_json = json_file.read()
  json_file.close()
  model = tf.keras.models.model_from_json(loaded_model_json)
  model.load_weights("./recognition_model/model.h5")
  return model


def dark_image(h,w):
    image = np.zeros((h, w, 3), np.uint8) * 255
    return image

#------------------------ ⬇⬇⬇ Extracting Shape Regions ⬇⬇⬇ -----------------------------
def fill(img):
  h,w=img.shape
  image=dark_image(h,w)
  cnts = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  cnts = cnts[0] if len(cnts) == 2 else cnts[1]
  for c in cnts:
      cv2.drawContours(image,[c], 0, (255,255,255), -1)
  return image

#------------------------- ➡➡➡ This block ends ⬅⬅⬅ --------------------------------

#------------------------ ⬇⬇⬇ Segmenting Red Regions ⬇⬇⬇ -----------------------------
def red_mask(image):
    lower_red_1 = np.array([0, 100, 20])
    upper_red_1 = np.array([10, 255, 255])

    lower_red_2 = np.array([160,100,20])
    upper_red_2 = np.array([179,255,255]) 
    
    lower_red_mask = cv2.inRange(image, lower_red_1, upper_red_1)
    upper_red_mask = cv2.inRange(image, lower_red_2, upper_red_2)

    red_full_mask = lower_red_mask + upper_red_mask

    return red_full_mask

def red_fill(img):
  h,w=img.shape
  image=dark_image(h,w)
  cnts = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  cnts = cnts[0] if len(cnts) == 2 else cnts[1]
  for c in cnts:
      cv2.drawContours(image,[c], 0, (255,0,0), -1)
  return image
#------------------------- ➡➡➡ This block ends ⬅⬅⬅ -----------------------------------


#-------------------------- ⬇⬇⬇ Segmenting Blue Regions ⬇⬇⬇---------------------------

def blue_mask(image):
    lower_blue_1 = np.array([112,50,50])
    upper_blue_1 = np.array([130,255,255])

    lower_blue_2 = np.array([96, 80, 2])
    upper_blue_2 = np.array([126, 255, 255])

    lower_blue_mask =cv2.inRange(image, lower_blue_1, upper_blue_1)
    upper_blue_mask =cv2.inRange(image, lower_blue_2, upper_blue_2)

    blue_full_mask = lower_blue_mask + upper_blue_mask 

    return blue_full_mask

def blue_fill(img):
  h,w=img.shape
  image=dark_image(h,w)
  cnts = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  cnts = cnts[0] if len(cnts) == 2 else cnts[1]
  for c in cnts:
      cv2.drawContours(image,[c], 0, (0,0,255), -1)
  return image

#------------------------- ➡➡➡ This block ends ⬅⬅⬅ -----------------------------------

#-------------------------- ⬇⬇⬇ Calculating Center of Image ⬇⬇⬇---------------------------
def coi(img):
  gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
  moment = cv2.moments(gray_img)
  X = int(moment ["m10"] / moment["m00"])
  Y = int(moment ["m01"] / moment["m00"])
  return X+10,Y+8
#------------------------- ➡➡➡ This block ends ⬅⬅⬅ -----------------------------------

def resize(img):
    # img= cv2.bilateralFilter(img,9,75,75)
    width = 32
    height = 32
    dim = (width, height)
    resized=cv2.resize(img, dim, interpolation = cv2.INTER_AREA)
    return resized


def shape_recognition(number, image):
    model=shapeModel()[0]
    labels=shapeModel()[1]
    image=resize(image)
    image_array= np.expand_dims(image, axis=0)
    predictions=model.predict(image_array)
    score = tf.nn.softmax(predictions[0])
    # return {f"{number +' '+ labels[i] }": float(score[i]) for i in range(len(labels))}
    return f'Shape {str(number)}:'+" "+ f'{labels[np.argmax(score)]}'

def ts_recognition(number, image):
    model=recognitionModel()
    labels=pd.read_csv('./recognition_model/labels.csv')
    labels=labels['Name']
    image=resize(image)
    image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
    image_array= np.expand_dims(image, axis=0)
    predictions=model(image_array)
    score = tf.nn.softmax(predictions[0])
    # return {f"{number +' '+ labels[i] }": float(score[i]) for i in range(len(labels))}
    return f'Sign {str(number)}:'+" "+ f'{labels[np.argmax(score)]}'

def outputs(roi):
    shape_n=[]
    color=[]
    sign=[]
    count=1
    for i in roi:
      result = i.copy()
      x,y=list(coi(i))
      image = cv2.cvtColor(result, cv2.COLOR_RGB2HSV)
      
      red_full_mask = red_mask(image)

      blue_full_mask = blue_mask(image)

      filled_red=red_fill(red_full_mask)
      filled_blue=blue_fill(blue_full_mask)

    #   x=center_of_image[0]
    #   y=center_of_image[1]

      rb_img=filled_red+filled_blue


      
      if list(rb_img[y,x])==[255,0, 0] or list(rb_img[y,x])==[255,0, 255]:
        # save(fill(red_full_mask))
        #print(fill(red_full_mask).shape)
        shape_n.append(shape_recognition(count,fill(red_full_mask)))
        color.append(f"Color {count}: Red")
        sign.append(ts_recognition(count,result))
      elif list(rb_img[y,x])==[0, 0, 255]:
        # print(fill(red_full_mask).shape)
        shape_n.append(shape_recognition(count,fill(blue_full_mask)))
        color.append(f"Color {count}: Blue")
        sign.append(ts_recognition(count,result))

      else:
        shape_n.append(f"Shape {count}: Undefined")
        color.append(f"Color {count}: Undefined")
        sign.append(ts_recognition(count,result))
      count+=1
    return shape_n, color ,sign

def detect(image):
    with tf.io.gfile.GFile('./detection_model/frozen_inference_graph.pb', 'rb') as f:
        graph_def = tf.compat.v1.GraphDef()
        graph_def.ParseFromString(f.read())

    with tf.compat.v1.Session() as sess:
        # Restore session
        sess.graph.as_default()
        tf.import_graph_def(graph_def, name='')

        # Read and preprocess an image.
        img = image
        cropper=img.copy()
        rows = img.shape[0]
        cols = img.shape[1]
        inp = cv2.resize(img, (300, 300))
        #inp = inp[:, :, [2, 1, 0]]  # BGR2RGB

        # Run the model
        out = sess.run([sess.graph.get_tensor_by_name('num_detections:0'),
                        sess.graph.get_tensor_by_name('detection_scores:0'),
                        sess.graph.get_tensor_by_name('detection_boxes:0'),
                        sess.graph.get_tensor_by_name('detection_classes:0')],
                    feed_dict={'image_tensor:0': inp.reshape(1, inp.shape[0], inp.shape[1], 3)})     
        # Visualize detected bounding boxes.
        num_detections = int(out[0][0])
        roi=[]
        for i in range(num_detections):
            classId = int(out[3][0][i])
            score = float(out[1][0][i])
            bbox = [float(v) for v in out[2][0][i]]
            if score > 0.8:
                x = (bbox[1] * cols) -10 #left
                y = (bbox[0] * rows) - 15 #top
                right = (bbox[3] * cols) + 10
                bottom = (bbox[2] * rows ) +10
                crop=cropper[int(y): int(bottom),int(x):int(right)]
                if crop.shape[0]!=0 and crop.shape[1]!=0:
                  roi.append(crop)
                  detect=cv2.rectangle(img, (int(x), int(y)), (int(right), int(bottom)), (15, 255,100), thickness=4)
                  cv2.putText(detect, f'{i+1}', (int(x), int(y-10)), cv2.FONT_HERSHEY_PLAIN, 0.8, (255,255,0), 2) 
    if roi:
      shape_n,color, sign=outputs(roi)
      return detect, ', '.join(shape_n), ', '.join(color), ', '.join(sign)
    else:
      return image, 'Undetected', 'Undetected', 'Undetected'

iface=gr.Interface(detect,
    inputs=gr.Image(label="Upload an Image"),
    outputs=[gr.Image(label="Detected Image"),
    gr.Label(label="Shape"),
    # gr.outputs.Image(label="Removed Background Image"),
    gr.Label(label="Color"),
    gr.Label(label="Signs")
    ],
    title="Bangladeshi Traffic Sign, Detection, Shape-Color Recognition & Classification",
    examples=['examples/1.jpg','./examples/2.jpg', './examples/4.jpg'],
    layout='center',
    description='The following is an Implementation of a Thesis paper done by Md. Ziaul Karim, \n for the Department of Software Engineering, Daffodil International University\'s Undergraduate program as a proof of concept.',
    theme='dark-peach',css='./style.css',article=f'© {date.today().year} Copyright | Made by <strong >Md. Ziaul Karim</strong> <a href="https://gradio.app/"> | with <strong>Gradio</strong></a>'
)

iface.launch(debug=True, favicon_path='./favicon.png',height=300,width=500)