Update app.py

app.py

@@ -31,194 +31,194 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 
 
 
-# processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
-# model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
-# plt.switch_backend('Agg')
-# def horizontal_projections(sobel_image):
-#     return np.sum(sobel_image, axis=1)  
+processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
+model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
+plt.switch_backend('Agg')
+def horizontal_projections(sobel_image):
+    return np.sum(sobel_image, axis=1)  
             
             
-# def find_peak_regions(hpp, divider=4):
-#     threshold = (np.max(hpp)-np.min(hpp))/divider
-#     peaks = []
+def find_peak_regions(hpp, divider=4):
+    threshold = (np.max(hpp)-np.min(hpp))/divider
+    peaks = []
     
-#     for i, hppv in enumerate(hpp):
-#         if hppv < threshold:
-#             peaks.append([i, hppv])
-#     return peaks
-
-# def heuristic(a, b):
-#     return (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2
-
-# def get_hpp_walking_regions(peaks_index):
-#     hpp_clusters = []
-#     cluster = []
-#     for index, value in enumerate(peaks_index):
-#         cluster.append(value)
-
-#         if index < len(peaks_index)-1 and peaks_index[index+1] - value > 1:
-#             hpp_clusters.append(cluster)
-#             cluster = []
-
-#         #get the last cluster
-#         if index == len(peaks_index)-1:
-#             hpp_clusters.append(cluster)
-#             cluster = []
+    for i, hppv in enumerate(hpp):
+        if hppv < threshold:
+            peaks.append([i, hppv])
+    return peaks
+
+def heuristic(a, b):
+    return (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2
+
+def get_hpp_walking_regions(peaks_index):
+    hpp_clusters = []
+    cluster = []
+    for index, value in enumerate(peaks_index):
+        cluster.append(value)
+
+        if index < len(peaks_index)-1 and peaks_index[index+1] - value > 1:
+            hpp_clusters.append(cluster)
+            cluster = []
+
+        #get the last cluster
+        if index == len(peaks_index)-1:
+            hpp_clusters.append(cluster)
+            cluster = []
             
-#     return hpp_clusters
+    return hpp_clusters
 
-# def astar(array, start, goal):
+def astar(array, start, goal):
 
-#         neighbors = [(0,1),(0,-1),(1,0),(-1,0),(1,1),(1,-1),(-1,1),(-1,-1)]
-#         close_set = set()
-#         came_from = {}
-#         gscore = {start:0}
-#         fscore = {start:heuristic(start, goal)}
-#         oheap = []
+        neighbors = [(0,1),(0,-1),(1,0),(-1,0),(1,1),(1,-1),(-1,1),(-1,-1)]
+        close_set = set()
+        came_from = {}
+        gscore = {start:0}
+        fscore = {start:heuristic(start, goal)}
+        oheap = []
 
-#         heappush(oheap, (fscore[start], start))
+        heappush(oheap, (fscore[start], start))
         
-#         while oheap:
-
-#             current = heappop(oheap)[1]
-
-#             if current == goal:
-#                 data = []
-#                 while current in came_from:
-#                     data.append(current)
-#                     current = came_from[current]
-#                 return data
-
-#             close_set.add(current)
-#             for i, j in neighbors:
-#                 neighbor = current[0] + i, current[1] + j            
-#                 tentative_g_score = gscore[current] + heuristic(current, neighbor)
-#                 if 0 <= neighbor[0] < array.shape[0]:
-#                     if 0 <= neighbor[1] < array.shape[1]:                
-#                         if array[neighbor[0]][neighbor[1]] == 1:
-#                             continue
-#                     else:
-#                         # array bound y walls
-#                         continue
-#                 else:
-#                     # array bound x walls
-#                     continue
+        while oheap:
+
+            current = heappop(oheap)[1]
+
+            if current == goal:
+                data = []
+                while current in came_from:
+                    data.append(current)
+                    current = came_from[current]
+                return data
+
+            close_set.add(current)
+            for i, j in neighbors:
+                neighbor = current[0] + i, current[1] + j            
+                tentative_g_score = gscore[current] + heuristic(current, neighbor)
+                if 0 <= neighbor[0] < array.shape[0]:
+                    if 0 <= neighbor[1] < array.shape[1]:                
+                        if array[neighbor[0]][neighbor[1]] == 1:
+                            continue
+                    else:
+                        # array bound y walls
+                        continue
+                else:
+                    # array bound x walls
+                    continue
                     
-#                 if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):
-#                     continue
+                if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):
+                    continue
                     
-#                 if  tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1]for i in oheap]:
-#                     came_from[neighbor] = current
-#                     gscore[neighbor] = tentative_g_score
-#                     fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
-#                     heappush(oheap, (fscore[neighbor], neighbor))
+                if  tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1]for i in oheap]:
+                    came_from[neighbor] = current
+                    gscore[neighbor] = tentative_g_score
+                    fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
+                    heappush(oheap, (fscore[neighbor], neighbor))
                     
-#         return []
-
-# def get_binary(img):
-#         mean = np.mean(img)
-#         if mean == 0.0 or mean == 1.0:
-#             return img
-
-#         thresh = threshold_otsu(img)
-#         binary = img <= thresh
-#         binary = binary*1
-#         return binary
-
-# def path_exists(window_image):
-#     #very basic check first then proceed to A* check
-#     if 0 in horizontal_projections(window_image):
-#         return True
+        return []
+
+def get_binary(img):
+        mean = np.mean(img)
+        if mean == 0.0 or mean == 1.0:
+            return img
+
+        thresh = threshold_otsu(img)
+        binary = img <= thresh
+        binary = binary*1
+        return binary
+
+def path_exists(window_image):
+    #very basic check first then proceed to A* check
+    if 0 in horizontal_projections(window_image):
+        return True
     
-#     padded_window = np.zeros((window_image.shape[0],1))
-#     world_map = np.hstack((padded_window, np.hstack((window_image,padded_window)) ) )
-#     path = np.array(astar(world_map, (int(world_map.shape[0]/2), 0), (int(world_map.shape[0]/2), world_map.shape[1])))
-#     if len(path) > 0:
-#         return True
+    padded_window = np.zeros((window_image.shape[0],1))
+    world_map = np.hstack((padded_window, np.hstack((window_image,padded_window)) ) )
+    path = np.array(astar(world_map, (int(world_map.shape[0]/2), 0), (int(world_map.shape[0]/2), world_map.shape[1])))
+    if len(path) > 0:
+        return True
     
-#     return False
+    return False
 
-# def get_road_block_regions(nmap):
-#     road_blocks = []
-#     needtobreak = False
+def get_road_block_regions(nmap):
+    road_blocks = []
+    needtobreak = False
     
-#     for col in range(nmap.shape[1]):
-#         start = col
-#         end = col+20
-#         if end > nmap.shape[1]-1:
-#             end = nmap.shape[1]-1
-#             needtobreak = True
-
-#         if path_exists(nmap[:, start:end]) == False:
-#             road_blocks.append(col)
-
-#         if needtobreak == True:
-#             break
+    for col in range(nmap.shape[1]):
+        start = col
+        end = col+20
+        if end > nmap.shape[1]-1:
+            end = nmap.shape[1]-1
+            needtobreak = True
+
+        if path_exists(nmap[:, start:end]) == False:
+            road_blocks.append(col)
+
+        if needtobreak == True:
+            break
             
-#     return road_blocks
-
-# def group_the_road_blocks(road_blocks):
-#     #group the road blocks
-#     road_blocks_cluster_groups = []
-#     road_blocks_cluster = []
-#     size = len(road_blocks)
-#     for index, value in enumerate(road_blocks):
-#         road_blocks_cluster.append(value)
-#         if index < size-1 and (road_blocks[index+1] - road_blocks[index]) > 1:
-#             road_blocks_cluster_groups.append([road_blocks_cluster[0], road_blocks_cluster[len(road_blocks_cluster)-1]])
-#             road_blocks_cluster = []
-
-#         if index == size-1 and len(road_blocks_cluster) > 0:
-#             road_blocks_cluster_groups.append([road_blocks_cluster[0], road_blocks_cluster[len(road_blocks_cluster)-1]])
-#             road_blocks_cluster = []
-
-#     return road_blocks_cluster_groups
-
-# def extract_line_from_image(image, lower_line, upper_line):
-#     lower_boundary = np.min(lower_line[:, 0])
-#     upper_boundary = np.min(upper_line[:, 0])
-#     img_copy = np.copy(image)
-#     r, c = img_copy.shape
-#     for index in range(c-1):
-#         img_copy[0:lower_line[index, 0], index] = 0
-#         img_copy[upper_line[index, 0]:r, index] = 0
+    return road_blocks
+
+def group_the_road_blocks(road_blocks):
+    #group the road blocks
+    road_blocks_cluster_groups = []
+    road_blocks_cluster = []
+    size = len(road_blocks)
+    for index, value in enumerate(road_blocks):
+        road_blocks_cluster.append(value)
+        if index < size-1 and (road_blocks[index+1] - road_blocks[index]) > 1:
+            road_blocks_cluster_groups.append([road_blocks_cluster[0], road_blocks_cluster[len(road_blocks_cluster)-1]])
+            road_blocks_cluster = []
+
+        if index == size-1 and len(road_blocks_cluster) > 0:
+            road_blocks_cluster_groups.append([road_blocks_cluster[0], road_blocks_cluster[len(road_blocks_cluster)-1]])
+            road_blocks_cluster = []
+
+    return road_blocks_cluster_groups
+
+def extract_line_from_image(image, lower_line, upper_line):
+    lower_boundary = np.min(lower_line[:, 0])
+    upper_boundary = np.min(upper_line[:, 0])
+    img_copy = np.copy(image)
+    r, c = img_copy.shape
+    for index in range(c-1):
+        img_copy[0:lower_line[index, 0], index] = 0
+        img_copy[upper_line[index, 0]:r, index] = 0
     
-#     return img_copy[lower_boundary:upper_boundary, :]
+    return img_copy[lower_boundary:upper_boundary, :]
 
-# def extract(image):
-#     img = rgb2gray(image)
+def extract(image):
+    img = rgb2gray(image)
 
-#     #img = rgb2gray(imread("Penwritten_2048x.jpeg"))
-#     #img = rgb2gray(imread("test.jpg"))
-#     #img = rgb2gray(imread(""))
+    #img = rgb2gray(imread("Penwritten_2048x.jpeg"))
+    #img = rgb2gray(imread("test.jpg"))
+    #img = rgb2gray(imread(""))
 
 
 
 
-#     sobel_image = sobel(img)
-#     hpp = horizontal_projections(sobel_image)
+    sobel_image = sobel(img)
+    hpp = horizontal_projections(sobel_image)
 
 
-#     warnings.filterwarnings("ignore")
-#     #find the midway where we can make a threshold and extract the peaks regions
-#     #divider parameter value is used to threshold the peak values from non peak values.
+    warnings.filterwarnings("ignore")
+    #find the midway where we can make a threshold and extract the peaks regions
+    #divider parameter value is used to threshold the peak values from non peak values.
 
 
-#     peaks = find_peak_regions(hpp)
+    peaks = find_peak_regions(hpp)
 
-#     peaks_index = np.array(peaks)[:,0].astype(int)
-#     #print(peaks_index.shape)
-#     segmented_img = np.copy(img)
-#     r= segmented_img.shape
-#     for ri in range(r[0]):
-#         if ri in peaks_index:
-#             segmented_img[ri, :] = 0
+    peaks_index = np.array(peaks)[:,0].astype(int)
+    #print(peaks_index.shape)
+    segmented_img = np.copy(img)
+    r= segmented_img.shape
+    for ri in range(r[0]):
+        if ri in peaks_index:
+            segmented_img[ri, :] = 0
 
-#     #group the peaks into walking windows
+    #group the peaks into walking windows
 
 
-#     hpp_clusters = get_hpp_walking_regions(peaks_index)
-#     #a star path planning algorithm 
+    hpp_clusters = get_hpp_walking_regions(peaks_index)
+    #a star path planning algorithm 
     
 
 
@@ -226,100 +226,100 @@ from sklearn.feature_extraction.text import TfidfVectorizer
     
 
 
-#     #Scan the paths to see if there are any blockers.
+    #Scan the paths to see if there are any blockers.
     
 
     
 
-#     binary_image = get_binary(img)
+    binary_image = get_binary(img)
 
-#     for cluster_of_interest in hpp_clusters:
-#         nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
-#         road_blocks = get_road_block_regions(nmap)
-#         road_blocks_cluster_groups = group_the_road_blocks(road_blocks)
-#         #create the doorways
-#         for index, road_blocks in enumerate(road_blocks_cluster_groups):
-#             window_image = nmap[:, road_blocks[0]: road_blocks[1]+10]
-#             binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:][:, road_blocks[0]: road_blocks[1]+10][int(window_image.shape[0]/2),:] *= 0
+    for cluster_of_interest in hpp_clusters:
+        nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
+        road_blocks = get_road_block_regions(nmap)
+        road_blocks_cluster_groups = group_the_road_blocks(road_blocks)
+        #create the doorways
+        for index, road_blocks in enumerate(road_blocks_cluster_groups):
+            window_image = nmap[:, road_blocks[0]: road_blocks[1]+10]
+            binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:][:, road_blocks[0]: road_blocks[1]+10][int(window_image.shape[0]/2),:] *= 0
 
-#     #now that everything is cleaner, its time to segment all the lines using the A* algorithm
-#     line_segments = []
-#     #print(len(hpp_clusters))
-#     #print(hpp_clusters)
-#     for i, cluster_of_interest in enumerate(hpp_clusters):
-#         nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
-#         path = np.array(astar(nmap, (int(nmap.shape[0]/2), 0), (int(nmap.shape[0]/2),nmap.shape[1]-1)))
-#         #print(path.shape)
-#         if path.shape[0]!=0:
-#             #break
-#             offset_from_top = cluster_of_interest[0]
-#             #print(offset_from_top)
-#             path[:,0] += offset_from_top
-#             #print(path)
-#             line_segments.append(path)
-#             #print(i)
+    #now that everything is cleaner, its time to segment all the lines using the A* algorithm
+    line_segments = []
+    #print(len(hpp_clusters))
+    #print(hpp_clusters)
+    for i, cluster_of_interest in enumerate(hpp_clusters):
+        nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
+        path = np.array(astar(nmap, (int(nmap.shape[0]/2), 0), (int(nmap.shape[0]/2),nmap.shape[1]-1)))
+        #print(path.shape)
+        if path.shape[0]!=0:
+            #break
+            offset_from_top = cluster_of_interest[0]
+            #print(offset_from_top)
+            path[:,0] += offset_from_top
+            #print(path)
+            line_segments.append(path)
+            #print(i)
 
-#     cluster_of_interest = hpp_clusters[1]
-#     offset_from_top = cluster_of_interest[0]
-#     nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
-#     #plt.figure(figsize=(20,20))
-#     #plt.imshow(invert(nmap), cmap="gray")
+    cluster_of_interest = hpp_clusters[1]
+    offset_from_top = cluster_of_interest[0]
+    nmap = binary_image[cluster_of_interest[0]:cluster_of_interest[len(cluster_of_interest)-1],:]
+    #plt.figure(figsize=(20,20))
+    #plt.imshow(invert(nmap), cmap="gray")
 
-#     path = np.array(astar(nmap, (int(nmap.shape[0]/2), 0), (int(nmap.shape[0]/2),nmap.shape[1]-1)))
-#     #plt.plot(path[:,1], path[:,0])
+    path = np.array(astar(nmap, (int(nmap.shape[0]/2), 0), (int(nmap.shape[0]/2),nmap.shape[1]-1)))
+    #plt.plot(path[:,1], path[:,0])
 
-#     offset_from_top = cluster_of_interest[0]
+    offset_from_top = cluster_of_interest[0]
 
 
 
-#     ## add an extra line to the line segments array which represents the last bottom row on the image
-#     last_bottom_row = np.flip(np.column_stack(((np.ones((img.shape[1],))*img.shape[0]), np.arange(img.shape[1]))).astype(int), axis=0)
-#     line_segments.append(last_bottom_row)
+    ## add an extra line to the line segments array which represents the last bottom row on the image
+    last_bottom_row = np.flip(np.column_stack(((np.ones((img.shape[1],))*img.shape[0]), np.arange(img.shape[1]))).astype(int), axis=0)
+    line_segments.append(last_bottom_row)
 
-#     line_images = []
+    line_images = []
 
 
 
     
-#     line_count = len(line_segments)
-#     fig, ax = plt.subplots(figsize=(10,10), nrows=line_count-1)
-#     output = []
+    line_count = len(line_segments)
+    fig, ax = plt.subplots(figsize=(10,10), nrows=line_count-1)
+    output = []
 
 
-#     for line_index in range(line_count-1):
-#         line_image = extract_line_from_image(img, line_segments[line_index], line_segments[line_index+1])
-#         line_images.append(line_image)
-#         #print(line_image)
-#         #cv2.imwrite('/Users/vatsalya/Desktop/demo.jpeg',line_image)
+    for line_index in range(line_count-1):
+        line_image = extract_line_from_image(img, line_segments[line_index], line_segments[line_index+1])
+        line_images.append(line_image)
+        #print(line_image)
+        #cv2.imwrite('/Users/vatsalya/Desktop/demo.jpeg',line_image)
         
 
-#         # im=Image.fromarray(line_image)
-#         # im=im.convert("L")
-#         # im.save("demo.jpeg")
-#         # print("#### Image Saved #######")
-#         new_p = Image.fromarray(line_image)
-#         if new_p.mode != 'RGB':
-#             new_p = new_p.convert('RGB')
-#         imageio.imwrite('demo.jpeg',new_p)
+        # im=Image.fromarray(line_image)
+        # im=im.convert("L")
+        # im.save("demo.jpeg")
+        # print("#### Image Saved #######")
+        new_p = Image.fromarray(line_image)
+        if new_p.mode != 'RGB':
+            new_p = new_p.convert('RGB')
+        imageio.imwrite('demo.jpeg',new_p)
 
 
 
-#         image = Image.open("demo.jpeg").convert("RGB")
+        image = Image.open("demo.jpeg").convert("RGB")
         
-#         #print("Started Processing")
-#         #image = line_image
-#         pixel_values = processor(images=image, return_tensors="pt").pixel_values
+        #print("Started Processing")
+        #image = line_image
+        pixel_values = processor(images=image, return_tensors="pt").pixel_values
 
-#         generated_ids = model.generate(pixel_values)
-#         generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-#         print(generated_text)
-#         output.append(generated_text)
-#         #ax[line_index].imshow(line_image, cmap="gray")
-#     result=""
-#     for o in output:
-#         result=result+o
-#         result=result+" "
-#     return result
+        generated_ids = model.generate(pixel_values)
+        generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        print(generated_text)
+        output.append(generated_text)
+        #ax[line_index].imshow(line_image, cmap="gray")
+    result=""
+    for o in output:
+        result=result+o
+        result=result+" "
+    return result
 
 
 
@@ -446,19 +446,7 @@ import requests
 import base64
 def extract_eval(image1,image2,image3,image4):
     print(image1)
-    #ideal_text=extract(image1)
-    
-    image_64_encode = base64.b64encode(image1)
-    print(image_64_encode)
-    print(image_64_encode.decode('utf-8'))
-    encode_string="data:image/png;base64,"+str(image_64_encode)
-    response = requests.post("https://mscsasem3-recogniser.hf.space/run/predict", json={
-    "data": [
-    #"data:image/png;base64,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",
-    encode_string
-    ]}).json()
-
-    ideal_text = response["data"]
+    ideal_text=extract(image1)
     print(data)
     print("Extracting Ideal Text \n")
     print(ideal_text)