Create new file

app1.py

@@ -0,0 +1,148 @@
+from keras.models import load_model
+import numpy as np # linear algebra
+import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
+import matplotlib.pyplot as plt
+import seaborn as sns
+from numpy import load
+import cv2
+
+
+import numpy.random as nr
+
+import warnings
+warnings.simplefilter(action='ignore')
+from PIL import Image, ImageFilter
+
+%matplotlib inline
+from google.colab import drive
+drive.mount('/content/drive')
+from google.colab.patches import cv2_imshow
+from PIL import Image
+from skimage.io import imread
+from skimage.morphology import convex_hull_image
+from skimage.color import rgb2gray
+import cv2
+nn = load_model('my_model-2.h5')
+def imageprepare(argv,Single):
+    """
+    This function returns the pixel values.
+    The input is a png file location.
+    """
+    img_gray=cv2.imread(argv,cv2.IMREAD_GRAYSCALE) # read image, image size is 180x180
+    (thresh, img_bin) = cv2.threshold(img_gray, 128, 255, cv2.THRESH_BINARY)
+    im=Image.fromarray(img_bin)
+    if Single==True:
+      rgb_im = im.convert("RGB")
+      rgb_im.save("ok.jpg")
+      im=crop_to_content('/content/ok.jpg')
+    width = float(im.size[0])
+    height = float(im.size[1])
+    newImage = Image.new('L', (28, 28), (255))  # creates white canvas of 28x28 pixels
+
+    if width > height:  # check which dimension is bigger
+        # Width is bigger. Width becomes 20 pixels.
+        nheight = int(round((20.0 / width * height), 0))  # resize height according to ratio width
+        if (nheight == 0):  # rare case but minimum is 1 pixel
+            nheight = 1
+            # resize and sharpen
+        img = im.resize((20, nheight), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
+        wtop = int(round(((28 - nheight) / 2), 0))  # calculate horizontal position
+        newImage.paste(img, (4, wtop))  # paste resized image on white canvas
+    else:
+        # Height is bigger. Heigth becomes 20 pixels.
+        nwidth = int(round((20.0 / height * width), 0))  # resize width according to ratio height
+        if (nwidth == 0):  # rare case but minimum is 1 pixel
+            nwidth = 1
+            # resize and sharpen
+        img = im.resize((nwidth, 20), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
+        wleft = int(round(((28 - nwidth) / 2), 0))  # caculate vertical pozition
+        newImage.paste(img, (wleft, 4))  # paste resized image on white canvas
+
+    # newImage.save("sample.png)
+
+    tv = list(newImage.getdata())  # get pixel values
+
+    # normalize pixels to 0 and 1. 0 is pure white, 1 is pure black.
+    tva = [(255 - x) * 1.0 / 255.0 for x in tv]
+    return tva
+
+def show(path):
+  img_gray=cv2.imread(path,cv2.IMREAD_GRAYSCALE) # read image, image size is 180x180
+  (thresh, img_bin) = cv2.threshold(img_gray, 140, 255, cv2.THRESH_BINARY)
+  im=Image.fromarray(img_bin)
+  rgb_im = im.convert("RGB")
+  rgb_im.save("ok.jpg")
+  # plt.imshow(rgb_im)
+  # plt.show()
+  # im=crop_to_content('/content/ok.jpg')
+  image = cv2.imread('/content/ok.jpg')
+  grey = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2GRAY)
+  ret, thresh = cv2.threshold(grey.copy(), 130, 255, cv2.THRESH_BINARY_INV)
+  contours, t = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+  preprocessed_digits=[]
+  for _, c in enumerate(contours):
+
+      # Get the bounding rectangle of the current contour:
+      boundRect = cv2.boundingRect(c)
+
+      # Get the bounding rectangle data:
+      rectX = boundRect[0]
+      rectY = boundRect[1]
+      rectWidth = boundRect[2]
+      rectHeight = boundRect[3]
+
+      # Estimate the bounding rect area:
+      rectArea = rectWidth * rectHeight
+
+      # Set a min area threshold
+      minArea = 1000
+      # Filter blobs by area:
+      if rectArea > minArea:
+
+          # Draw bounding box:
+          color = (0, 255, 0)
+          cv2.rectangle(image, (int(rectX), int(rectY)),
+                        (int(rectX + rectWidth), int(rectY + rectHeight)), color, 2)
+          # Crop bounding box:
+          currentCrop = image[rectY:rectY+rectHeight,rectX:rectX+rectWidth]
+          # cv2_imshow(currentCrop)
+          # cv2.waitKey(0)
+          cv2.imwrite("image.jpg", currentCrop)
+          x=imageprepare("image.jpg",False)
+          digit=np.array(x)
+          prediction = nn.predict(digit.reshape(1, 28, 28, 1))
+          print(np.argmax(prediction))
+          cv2.putText(image,str(np.argmax(prediction)),(rectX,rectHeight+rectY+50),cv2.FONT_HERSHEY_COMPLEX,2,(50,50,225),2)
+  status = cv2.imwrite('/content/kok.jpg',image)
+  return "/content/kok.jpg"
+import numpy as np
+import gradio as gr
+
+def predict_sketch(img):
+  img_3d=img.reshape(-1,28,28)
+  im_resize=img_3d/255.0
+  prediction=nn.predict(im_resize).tolist()[0]
+  return {str(i):prediction[i] for i in range(10)}
+
+def predict_upload(image):
+  im1 = image.save("/content/geeks.jpg")
+  k=show("/content/geeks.jpg")
+  return k
+
+with gr.Blocks() as demo:
+    gr.Markdown("Flip text or image files using this demo.")
+    with gr.Tabs():
+        with gr.TabItem("Sketch"):
+          with gr.Row():
+            text_input = gr.Sketchpad()
+            text_output = gr.Label(num_top_classes=3)
+          text_button = gr.Button("Submit")
+        with gr.TabItem("Upload Image"):
+            with gr.Row():
+                image_input =  gr.Image(type="pil",)
+                image_output =  gr.Image(type="pil",)
+            image_button = gr.Button("Submit")
+    image_button.click(predict_upload,image_input, image_output)
+    text_button.click(predict_sketch,text_input,outputs=text_output)
+
+demo.launch(debug=True)