breakword1

from skimage.io import imread, imshow
from skimage.filters import gaussian, threshold_otsu
from skimage.feature import canny
from skimage.transform import probabilistic_hough_line, rotate

#testing
import numpy as np
import os
import cv2
import math
import matplotlib.pyplot as plt
import imghdr

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms, models



from collections import OrderedDict
from PIL import Image

import pandas as pd
import seaborn as sns


def preprocess(img):


    img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    img = cv2.inRange(img,221,255,3)
    img = cv2.merge([img,img,img])
    cv2.imshow("hello",img)
    #cv2.waitKey(0)
    return img
# define the CNN architecture
class Net(nn.Module):
    ### TODO: choose an architecture, and complete the class

    def __init__(self):
        super(Net, self).__init__()

        # convolutional layer (sees 64x64x3 image tensor)
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        # convolutional layer (sees 32x32x16 tensor)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        # convolutional layer (sees 16x16x32 tensor)
        self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
        # convolutional layer (sees 8x8x64 tensor)
        self.conv4 = nn.Conv2d(64, 128, 3, padding=1)
        self.conv5 = nn.Conv2d(128, 256, 3, padding=1)

        # max pooling layer
        self.pool = nn.MaxPool2d(2, 2)
        # linear layer (256 * 2 * 2 -> 512)
        self.fc1 = nn.Linear(256 * 2 * 2 , 2048)
        # linear layer (512 -> 50)
        self.fc2 = nn.Linear(2048,512)
        # dropout layer (p=0.2)
        self.dropout = nn.Dropout(0.2)
        self.fc3 = nn.Linear(512,50)
        #self.softmax = nn.Softmax(dim=1)



    def forward(self, x):
        # add sequence of convolutional and max pooling layers
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = self.pool(F.relu(self.conv4(x)))
        x = self.pool(F.relu(self.conv5(x)))
        # flatten image input
        x = x.view(-1, 256*2*2)

        # add dropout layer
        x = self.dropout(x)
        # add 1st hidden layer, with relu activation function
        x = F.relu(self.fc1(x))
        # add dropout layer
        x = self.dropout(x)
        # add 2nd hidden layer, with relu activation function
        x = self.fc2(x)
        x = self.dropout(x)
        x = self.fc3(x)
        return x
train_on_gpu = torch.cuda.is_available()
'''
if not train_on_gpu:
    print('CUDA is not available.  Training on CPU ...')
else:
    print('CUDA is available!  Training on GPU ...')
'''

classes=['অ','আ','ই', 'ঈ', 'উ','ঊ','ঋ','এ','ঐ', 'ও' ,   'ঔ','ক', 'খ',   'গ',    'ঘ',    'ঙ',    'চ',    'ছ',    'জ',    'ঝ',    'ঞ',    'ট',
    'ঠ',    'ড',    'ঢ',    'ণ',    'ত',    'থ',    'দ',    'ধ',    'ন',        'প',    'ফ',    'ব',    'ভ',    'ম',    'য',    'র',        'ল',                'শ' ,   'ষ',    'স' ,   'হ' ,
    'ড়','ঢ়','য়','ৎ','ং', ':', '৺']

model_scratch = Net()
model_scratch.load_state_dict(torch.load('model_scratch.pt' , map_location=torch.device('cpu')))


def process_image(image):
    ''' Scales, crops, and normalizes a PIL image for a PyTorch model

    '''
    img=preprocess(image)
    #img = cv2.fastNlMeansDenoising(img, img, 50.0, 7, 21)

    transformation = transforms.Compose([transforms.ToPILImage(),
                                         transforms.Resize([64,64]),
                                      #transforms.Grayscale(num_output_channels=1),
                                      transforms.ToTensor(),
                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                      ])
    #print("dklsfdks")
    return transformation(img)

def predict(image, model,topk=2):
    ''' Predict the class (or classes) of an image using a trained deep learning model.
    '''
    model.to('cpu')
    #print("hello")
    image = process_image(image)
    image = image.unsqueeze_(0)
    print("world")
    model.eval()
    with torch.no_grad():
        output = model.forward(image)

    m = nn.Softmax(dim=1)
    probabilities = m(output)

    topk_probabilities, topk_labels = probabilities.topk(topk)
    print([topk_probabilities, topk_labels])
    # convert output probabilities to predicted class
    _, preds_tensor = torch.max(output, 1)
    #print(probabilities)
    #print(preds_tensor)
    preds = np.squeeze(preds_tensor.numpy()) if not train_on_gpu else np.squeeze(preds_tensor.cpu().numpy())
    print('predicted label no: '+str(preds))
    if(topk_probabilities[0][0].numpy()>0.9):
        return(classes[preds])
    else:
        return 0
#img=Image.open(r'F:\Thesis Files\CMATERdb 3.1.2\BasicFinalDatabase\Test\183\bcc000027.bmp')
#print(predict(img,model_scratch))
#img = cv2.imread('C:/Users/Sajid/sliced92.png',cv2.IMREAD_GRAYSCALE)
img=Image.open(r'C:\Users\Sajid\B00991.jpg')
img=np.uint8(img)

print(predict(img,model_scratch))

#img = np.array(img)
cv2.imshow("input",img)


#cv2.waitKey(0)


he,we,dummy=img.shape
print(he)
print(we)
jump=math.ceil(we/10)
right=we
left=we
bottom=0
top=he
letters=[]
cnt=0
last=1
#print("dskldfjks")
#imghdr.what(img)
for i in range(0,105):
    left=left-jump
    if left<0:
        left=0

    im1=img[bottom:top,left:right].copy()
    print(im1.shape)
    im1=np.uint8(im1)
    #imghdr.what(im1)
    cv2.imshow('img %d' % i,im1)
    print(i)
    x=predict(im1,model_scratch)
    print(x)
    if x==0:
        if left==0:
            break
        else:
            continue
    if cnt==0:
        cnt=cnt+1
        last=x
    elif cnt==1:
        if last==x:
            cnt=cnt+1
        else:
            last=x
            cnt=1
    else:
        if last==x:
            #letters.insert(0,x)
            letters.append(x)
            cnt=0
            right=left
        else:
            last=x
            cnt=1
    if left==0:
        break


for i in letters:
    print("yo yo")
    print(i)
cv2.waitKey(0)