Create app.py

app.py

@@ -0,0 +1,1095 @@
+import sys
+from paddleocr import PaddleOCR
+import cv2
+import numpy as np  
+import pandas as pd
+import os
+
+# sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+
+from doctr.models import ocr_predictor
+from torch.utils.data import DataLoader
+from doctr.io import DocumentFile
+
+
+import math
+from typing import Tuple, Union
+
+import cv2
+import numpy as np
+import os
+
+from deskew import determine_skew
+
+
+
+
+print(sys.version)
+ocr = PaddleOCR(lang='en')
+model = ocr_predictor(pretrained=True)
+
+ocr = PaddleOCR(lang='en')
+
+
+
+def find_surr_keys(unassigned_key, known_keys):
+    # Sort known keys
+    print(known_keys)
+    known_keys = sorted(known_keys)
+    # Initialize distances and closest keys
+    closest_keys = []
+    for k in known_keys:
+         closest_keys.append((abs(int(k) - int(unassigned_key)), k))
+    # Sort by distance
+    closest_keys.sort()
+    # Return the two closest known keys
+    if(closest_keys[0][1]<unassigned_key and closest_keys[0][1]>unassigned_key):
+        return [closest_keys[0][1], closest_keys[1][1]]
+    else:
+        raise ValueError(f"No closest keys found for unassigned key: {unassigned_key}")
+
+def label_text(text):
+    # Define the two lists
+    list1 = ['t', 'r', 'u', 'T', 'R', 'U']
+    list2 = ['f', 'a', 'l', 's', 'F', 'A', 'L', 'S']
+    
+    # Count the matches for each list
+    count1 = sum(text.count(char) for char in list1)
+    count2 = sum(text.count(char) for char in list2)
+    
+    # Determine the label based on the counts
+    if count1 > count2:
+        return True
+    elif count1!=0 or count2!=0:
+        return False
+
+
+def percentMatch(text1,text2):
+    list = ['t', 'r', 'u', 'T', 'R', 'U','f', 'a', 'l', 's', 'F', 'A', 'L', 'S']
+
+    if(text1):
+        count1 = sum(text1.count(char) for char in list)
+       
+        
+        count2 = sum(text2.count(char) for char in list)
+
+        if(count1==3 and count2==4 or count1==4 and count2==3 ):  #if one says true and other says false then priority given to 2nd
+            print("true and false collision so given priority to text2 which is the incoming text")
+            return 2
+
+        if(count1>count2):
+            print("text1 i.e the prev text is the winner")
+            return 1
+        else:
+            print("text2 i.e the incoming text is the winner")
+            return 2
+    else:
+        print("text1 not there so text2 is the winner")
+        return 2
+
+def count_true_false(d): #in a dictionary to check how many T/F are there.
+    true_count = sum(1 for v in d.values() if v is True)
+    false_count = sum(1 for v in d.values() if v is False)
+    return true_count, false_count
+
+def merge_dicts(dict1, dict2): 
+    true_count1, false_count1 = count_true_false(dict1)
+    true_count2, false_count2 = count_true_false(dict2)
+    
+    if (true_count1 + false_count1) >= (true_count2 + false_count2):
+        final_dict = dict1.copy()
+        y_dirn_gap=False
+    else:
+        final_dict = dict2.copy()
+        y_dirn_gap=True
+
+    return final_dict,y_dirn_gap
+
+
+def assign_true_false_or_unknown(true_list, false_list, question_dict,total_questions):
+    # Initialize the final dictionary
+    final_dict = {str(i): 'UNASSIGNED' for i in range(1, total_questions+1)}
+    unassigned_keys=[]
+    assigned_keys=[]
+    
+    # Iterate over each question and its y-coordinate
+    for question, y in question_dict.items():
+        # compute diff with true list such that we sub t/f box from s/n box
+        # true_differences= [y - ty for ty in true_list]
+        # Compute absolute differences with true list
+        true_abs_differences = [abs(y - ty) for ty in true_list]
+        # Compute absolute differences with false list
+        # false_differences= [y - ty for ty in false_list]
+        false_abs_differences = [abs(y - fy) for fy in false_list]
+
+
+        # Find the minimum differences
+  
+        # min_true_diff = min((diff for diff in true_differences if diff > 0), default=float('inf'))
+        # min_false_diff = min((diff for diff in false_differences if diff > 0), default=float('inf'))
+
+        
+        min_true_abs_diff=min(true_abs_differences) if true_abs_differences else float('inf')
+        min_false_abs_diff=min(false_abs_differences) if false_abs_differences else float('inf')
+
+        # Determine the smallest difference
+        # min_diff = min(min_true_diff, min_false_diff)
+        min_abs_diff=min(min_true_abs_diff,min_false_abs_diff)
+
+
+        # Assign the value based on the smallest difference
+        # if min_diff < 360:
+        #     if min_true_diff < min_false_diff:
+        #         final_dict[question] = True
+        #         true_list.pop(true_differences.index(min_true_diff))
+        #     else:
+        #         final_dict[question] = False
+        #         false_list.pop(false_differences.index(min_false_diff))
+        # else:
+            # checking the abs diff option if nothing can find in positive diff option
+        if min_abs_diff < 300:
+            if min_true_abs_diff < min_false_abs_diff:
+                final_dict[question] = True
+                true_list.pop(true_abs_differences.index(min_true_abs_diff))
+            else:
+                final_dict[question] = False
+                false_list.pop(false_abs_differences.index(min_false_abs_diff))
+            
+        else:
+            final_dict[question] = 'NULL'
+   
+
+    
+    
+   
+
+                         
+    return final_dict
+
+
+def assign_true_false_or_unknown_rotated(true_list,false_list,true_list_x,false_list_x,question_dict,question_dict_x,total_questions):
+    final_dict = {str(i): 'UNASSIGNED' for i in range(1, total_questions+1)}
+    unassigned_keys=[]
+    assigned_keys=[]
+    final_dict_y={str(i): 'UNASSIGNED' for i in range(1, total_questions+1)}
+    final_dict_x={str(i): 'UNASSIGNED' for i in range(1, total_questions+1)}
+
+    # Iterate over each question and its y-coordinate
+    for question, y in question_dict.items():
+        # Compute absolute differences with true list
+        true_differences= [y - ty for ty in true_list]
+        true_abs_differences = [abs(y - ty) for ty in true_list]
+        # Compute absolute differences with false list
+        false_differences= [y - fy for fy in false_list]
+        false_abs_differences = [abs(y - fy) for fy in false_list]
+
+
+        # Find the minimum differences
+  
+        min_true_diff = min((diff for diff in true_differences if diff > 0), default=float('inf'))
+        min_false_diff = min((diff for diff in false_differences if diff > 0), default=float('inf'))
+
+        
+        min_true_abs_diff=min(true_abs_differences) if true_abs_differences else float('inf')
+        min_false_abs_diff=min(false_abs_differences) if false_abs_differences else float('inf')
+
+        # Determine the smallest difference
+        min_diff = min(min_true_diff, min_false_diff)
+        min_abs_diff=min(min_true_abs_diff,min_false_abs_diff)
+
+        # print("the question number is :",question)
+        # print("the min dist is :",min_diff)
+        # print("the min abs_diff is :",min_abs_diff)
+        # print("the false abs diff",false_abs_differences)
+        
+
+
+        # Assign the value based on the smallest difference first going with abs diff as for upside down it will favour abs
+        if min_abs_diff < 310:
+            if min_true_abs_diff < min_false_abs_diff:
+                final_dict_y[question] = True
+                true_list.pop(true_abs_differences.index(min_true_abs_diff))
+            else:
+                final_dict_y[question] = False
+                false_list.pop(false_abs_differences.index(min_false_abs_diff))
+        else:
+            # checking the postive diff option if nothing can find in abs diff option
+            if min_diff < 310:
+                print(question)
+                if min_true_diff < min_false_diff:
+
+                    final_dict_y[question] = True
+                    true_list.pop(true_differences.index(min_true_diff))
+                else:
+                    final_dict_y[question] = False
+                    false_list.pop(false_differences.index(min_false_diff))
+            
+            else:
+                final_dict_y[question] = 'NULL'
+   
+
+
+
+    for question,x in question_dict_x.items():
+    
+        # Compute absolute differences with true list
+        true_differences= [x - tx for tx in true_list_x]
+        true_abs_differences = [abs(x - tx) for tx in true_list_x]
+        # Compute absolute differences with false list
+        false_differences= [x - fy for fy in false_list_x]
+        false_abs_differences = [abs(x - fy) for fy in false_list_x]
+
+
+        # Find the minimum differences
+  
+        min_true_diff = min((diff for diff in true_differences if diff > 0), default=float('inf'))
+        min_false_diff = min((diff for diff in false_differences if diff > 0), default=float('inf'))
+
+        
+        min_true_abs_diff=min(true_abs_differences) if true_abs_differences else float('inf')
+        min_false_abs_diff=min(false_abs_differences) if false_abs_differences else float('inf')
+
+        # Determine the smallest difference
+        min_diff = min(min_true_diff, min_false_diff)
+        min_abs_diff=min(min_true_abs_diff,min_false_abs_diff)
+
+        if min_diff < 310:
+            if min_true_diff < min_false_diff:
+                final_dict_x[question] = True
+                true_list_x.pop(true_differences.index(min_true_diff))
+            else:
+                final_dict_x[question] = False
+                false_list_x.pop(false_differences.index(min_false_diff))
+        else:
+            # checking the abs diff option if nothing can find in positive diff option
+            if min_abs_diff < 310:
+                if min_true_abs_diff < min_false_abs_diff:
+                    final_dict_x[question] = True
+                    true_list_x.pop(true_abs_differences.index(min_true_abs_diff))
+                else:
+                    final_dict_x[question] = False
+                    false_list_x.pop(false_abs_differences.index(min_false_abs_diff))
+            
+            else:
+                final_dict_x[question] = 'NULL'
+    
+    
+    print("the final dict for y is: ")
+    print(final_dict_y)
+    print("the final dict for x is: ")
+    print(final_dict_x)
+    final_dict,y_dirn_gap=merge_dicts(final_dict_x,final_dict_y)
+
+   
+    if 'L' in final_dict:
+        final_dict['7']=final_dict['L']
+        del final_dict['L']
+        
+    if 'I' in final_dict:
+        final_dict['1']=final_dict['I']
+        del final_dict['I']
+    
+    if y_dirn_gap and '6' in final_dict and '9' in final_dict: #means image is inverted and 6 and 9 true and false value needs to swapped out
+        temp=final_dict['6']
+        final_dict['6']=final_dict['9']
+        final_dict['9']=temp
+
+    
+    return final_dict
+
+def process_using_paddleocr(image_path,output_folder,output_folder1,total_questions):
+    
+    ocr = PaddleOCR(lang='en')
+    base_name = os.path.basename(image_path)
+    image_cv = cv2.imread(image_path)
+    print("!------------------------------start with paddleocr-----------------------------------!")
+    print("Started processing of the image :",base_name)
+    
+    output = ocr.ocr(image_path)[0]
+
+
+    
+    texts = [line[1][0] for line in output]
+   
+ 
+    
+
+    
+    print("OCR detection done")
+
+    boxes = [line[0] for line in output]
+    # probabilities = [line[1][1] for line in output]
+
+
+
+    image_boxes = image_cv.copy()
+
+
+
+    # print("!------------------------------all coordinates-----------------------------------!")
+
+    for box,text in zip(boxes,texts):
+      cv2.rectangle(image_boxes,(int(box[0][0]),int(box[0][1])),(int(box[2][0]),int(box[2][1])),(0,0,255),5)  #needs top left and bottom right to draw bounding box
+      cv2.putText(image_boxes,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,4,(222,0,0),3)
+    
+    
+
+
+
+
+    alldet_file_name = f'detect_{base_name}'
+    alldet_file_path = os.path.join(output_folder1, alldet_file_name)
+    
+    # Save the processed image
+    cv2.imwrite(alldet_file_path, image_boxes)
+  
+
+
+    for box, text in zip(boxes, texts):
+      if text=="SN" or text=="NS":
+        num_l_x1=box[0][0]
+        num_r_x1=box[2][0]+140
+        num_l_y1=box[0][1]
+        num_r_y1=box[2][1]+140
+        print("left top x of SN:",num_l_x1)
+        print("bottom right x of SN:",num_r_x1)
+        print("left top y of SN:",num_l_y1)
+        print("bottom right y of SN:",num_r_y1)
+
+
+
+
+    cons_boxes_image=image_cv.copy()
+    true_list=[]
+    false_list=[]
+
+    true_list_x=[]
+    false_list_x=[]
+
+
+    numbers_dict={}
+    numbers_dict_x={}
+    c=0
+    prev_x=0
+    prev_y=0
+
+
+    # this is for s/n column
+    try:
+        for box, text in zip(boxes, texts):
+            # print(f"the text is : {text}")
+
+            
+            box_top_left_x = int(box[0][0])
+            box_top_left_y=int(box[0][1])
+            box_bottom_right_x = int(box[2][0])
+            box_bottom_right_y = int(box[2][1])
+            box_width_x = box_bottom_right_x - box_top_left_x
+            box_width_y = box_bottom_right_y - box_top_left_y
+            if (num_l_x1 <= box_bottom_right_x <= num_r_x1 or num_l_y1<= box_bottom_right_y<=num_r_y1) and box_width_x <= 200 and box_width_y <= 200 and text!="SN" and text!="NS":
+                # print("entered in the S/N column ")
+                # print(text)
+                # print(box)
+                numbers_dict[text] = int(box[0][1])
+                numbers_dict_x[text]=int(box[0][0])
+            
+                cv2.rectangle(cons_boxes_image, (int(box[0][0]), int(box[0][1])), (int(box[2][0]), int(box[2][1])), (0, 0, 255), 5)
+                cv2.putText(cons_boxes_image, text, (int(box[0][0]), int(box[0][1])), cv2.FONT_HERSHEY_SIMPLEX, 4, (222, 0, 0), 1)
+
+
+
+
+
+        
+        
+        
+   
+                       
+
+
+    #error in detection of S/N column   
+    except NameError:
+        print("cant detect s/n column also so going with all detection using box width")
+        c=0
+        for box,text in zip(boxes,texts):
+            box_top_left_x = int(box[0][0])
+            box_top_left_y=int(box[0][1])
+            box_bottom_right_x = int(box[2][0])
+            box_bottom_right_y = int(box[2][1])
+            box_width_x = box_bottom_right_x - box_top_left_x
+            box_width_y = box_bottom_right_y - box_top_left_y
+            
+            
+            if (box_width_x <= 80 and box_width_y <= 80):
+                if text.isdigit():
+                    number = int(text)
+                    if 1 <= number <= total_questions+1:
+                        # Store in dictionaries only if the number is between 1 and 10
+                        numbers_dict[text] = int(box[0][1])
+                        numbers_dict_x[text] = int(box[0][0])
+
+                        # Visualize the rectangle and text on the image (optional)
+                        cv2.rectangle(cons_boxes_image, (int(box[0][0]), int(box[0][1])), (int(box[1][0]), int(box[1][1])), (0, 0, 255), 5)
+                        cv2.putText(cons_boxes_image, text, (int(box[0][0]), int(box[0][1])), cv2.FONT_HERSHEY_SIMPLEX, 4, (222, 0, 0), 1)
+
+            if((box_width_x<=300 and box_width_y<=300) and ' ' not in text and label_text(text)==True):
+                if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev_y=box[0][1]
+                        prev_x=box[0][0]
+                        true_list.append(int(box[0][1]))
+                        true_list_x.append(int(box[0][0]))
+                            
+                else:
+                            
+                    if((abs(box[0][0]-prev_x)>160) or  abs(box[0][1]-prev_y)>160):
+                        print(text)
+                        print(box)
+                        true_list.append(int(box[0][1]))
+                        true_list_x.append(int(box[0][0]))
+                        prev_y=box[0][1]
+                        prev_x=box[0][0]
+                        
+                    c+=1
+
+                cv2.rectangle(cons_boxes_image,(int(box[0][0]),int(box[0][1])),(int(box[2][0]),int(box[2][1])),(0,0,255),5)  
+                cv2.putText(cons_boxes_image,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,4,(222,0,0),1)
+                
+            if((box_width_x<=300 and box_width_y<=300) and ' ' not in text and label_text(text)==False):
+                if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev_y=box[0][1]
+                        prev_x=box[0][0]
+
+                        false_list.append(int(box[0][1]))
+                        false_list_x.append(int(box[0][0]))
+                else:
+                            
+                    if((abs(box[0][0]-prev_x)>160) or  abs(box[0][1]-prev_y)>160):
+                        print(text)
+                        print(box)
+                        false_list.append(int(box[0][1]))
+                        false_list_x.append(int(box[0][0]))
+                        prev_y=box[0][1]
+                        prev_x=box[0][0]
+                    
+                    c+=1
+                
+                cv2.rectangle(cons_boxes_image,(int(box[0][0]),int(box[0][1])),(int(box[2][0]),int(box[2][1])),(0,0,255),5)  
+                cv2.putText(cons_boxes_image,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,4,(222,0,0),1)
+        
+        print("the number dict is: ",numbers_dict)
+        print("the number dict x is: ",numbers_dict_x)
+        print("the true list is ",true_list)
+        print("the false list is ",false_list)
+        print("the true list for xdirn",true_list_x)
+        print("the false list for xdirn",false_list_x)
+
+        final_dict=assign_true_false_or_unknown_rotated(true_list,false_list,true_list_x,false_list_x,numbers_dict,numbers_dict_x,total_questions)
+            # Create a unique output file name
+        output_file_name = f'final_tf_{base_name}'
+        output_file_path = os.path.join(output_folder, output_file_name)
+
+        # Save the processed image
+        cv2.imwrite(output_file_path, cons_boxes_image)
+
+
+
+
+    return final_dict
+
+                  
+
+
+
+def rotate(
+        image: np.ndarray, angle: float, background: Union[int, Tuple[int, int, int]]
+) -> np.ndarray:
+    old_width, old_height = image.shape[:2]
+    angle_radian = math.radians(angle)
+    width = abs(np.sin(angle_radian) * old_height) + abs(np.cos(angle_radian) * old_width)
+    height = abs(np.sin(angle_radian) * old_width) + abs(np.cos(angle_radian) * old_height)
+
+    image_center = tuple(np.array(image.shape[1::-1]) / 2)
+    rot_mat = cv2.getRotationMatrix2D(image_center, angle, 1.0)
+    rot_mat[1, 2] += (width - old_width) / 2
+    rot_mat[0, 2] += (height - old_height) / 2
+    return cv2.warpAffine(image, rot_mat, (int(round(height)), int(round(width))), borderValue=background)
+
+def process_using_doctr_less_row_gap(boxes,texts,numbers_dict,num_l_x2,num_r_x2,image_path,total_questions):
+    print("the number dict in low gap",numbers_dict)
+    cons_boxes_image = cv2.imread(image_path)
+    true_list=[]
+    false_list=[]
+    c=0
+    print("starting with low row gap")
+
+    try:
+        for box, text in zip(boxes, texts):
+            box_bottom_right_x = int(box[1][0])
+                
+            
+                
+    
+            # Draw the adjusted bounding box
+            if (num_l_x2 <=  box_bottom_right_x <= num_r_x2):
+                    # print("entered in the t/f column ")
+                
+                if label_text(text)==True and text!='TRUE/FALSE':
+                    if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev=box[0][1]
+                        prev_text=text
+                        true_list.append(int(box[0][1]))
+                    else:
+                    
+                        if(abs(box[0][1]-prev)>20):  #to avoid boxes in same row to overlap 
+                            print(text)
+                            print(box)
+                            true_list.append(int(box[0][1]))
+                            prev=box[0][1]
+                            prev_text=text
+                        else:
+                            print(f"collision happend with box:{prev} and text:{prev_text} solving on the basis of percent match boxes")
+                            print("the current box specification are")
+                            print(text)
+                            print(box)
+                            ans=percentMatch(prev_text,text)
+                            if(ans==2):
+
+                                if(label_text(prev_text)==False):
+                                    false_list.pop()
+                            
+                                elif(label_text(prev_text)==True):
+                                    true_list.pop()
+                            
+                            
+                                prev=box[0][1]
+                                prev_text=text
+                                true_list.append(int(prev))
+                            
+                            
+                                    
+
+                    c+=1
+                    
+                elif label_text(text)==False and text!='TRUE/FALSE':
+                    if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev=box[0][1]
+                        prev_text=text
+                        false_list.append(int(box[0][1]))
+                    else:
+                        if(abs(box[0][1]-prev)>20):
+                            print(text)
+                            print(box)
+                            false_list.append(int(box[0][1]))
+                            prev=box[0][1]
+                            prev_text=text
+                        else:
+                            print(f"collision happend with box:{prev} and text:{prev_text} solving on the basis of percent match boxes")
+                            print("the current box specification are")
+                            print(text)
+                            print(box)
+                            ans=percentMatch(prev_text,text)
+
+                            if(ans==2):
+
+                                if(label_text(prev_text)==False):
+                                    false_list.pop()
+                            
+                                elif(label_text(prev_text)==True):
+                                    true_list.pop()
+                                
+                                
+                                prev=box[0][1]
+                                prev_text=text
+                                false_list.append(int(prev))
+                    c+=1
+
+                cv2.rectangle(cons_boxes_image,(int(box[0][0]),int(box[0][1])),(int(box[1][0]),int(box[1][1])),(0,0,255),5)  
+                cv2.putText(cons_boxes_image,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,1,(222,0,0),1)
+        
+        
+    
+
+        final_dict=assign_true_false_or_unknown(true_list,false_list,numbers_dict,total_questions)
+        
+        return cons_boxes_image,final_dict
+    except Exception as e:
+        print("error occured")
+        print(e)
+
+
+def process_and_save_image(image_path,actual_ans_csv ,output_folder , output_folder1):
+
+    base_name = os.path.basename(image_path)
+    image_cv = cv2.imread(image_path)
+    height = image_cv.shape[0]
+    width = image_cv.shape[1]
+    print("!------------------------------starting detection using doctr-----------------------------------!")
+    print("Started processing of the image :",base_name)
+    # print(image_width)
+    # output = ocr.ocr(image_path)[0]
+
+    # checking if header is there
+    with open(actual_ans_csv, 'r') as file:
+        first_line = file.readline().strip()
+
+    
+    # Check if the first column of the first line is numeric
+    first_column_numeric = False
+    try:
+        first_value = float(first_line.split(',')[0])  # Assuming comma-separated values
+        first_column_numeric = True
+    except ValueError:
+        pass  # If the first column cannot be converted to a float, it's not numeric
+
+    
+    # Read the CSV file based on the condition
+    if first_column_numeric:
+        actualAns_df = pd.read_csv(actual_ans_csv, header=None)
+    else:
+        actualAns_df = pd.read_csv(actual_ans_csv)
+    
+    total_questions = len(actualAns_df)
+
+    #checking skewness
+    grayscale = cv2.cvtColor(image_cv, cv2.COLOR_BGR2GRAY)
+    angle = determine_skew(grayscale)
+    image_cv = rotate(image_cv, angle, (0, 0, 0))
+    cv2.imwrite(image_path, image_cv)
+
+
+    single_img_doc = DocumentFile.from_images(image_path)
+    result = model(single_img_doc)
+
+
+
+ 
+
+
+    texts=[]
+ 
+    for page in result.pages:
+        for block in page.blocks:
+            for line in block.lines:
+                for word in line.words:
+                    text = word.value
+                    texts.append(text)
+  
+
+
+   
+    #checking for rotation
+    r_count=0
+
+    while('TRUE/FALSE' not in texts):
+        image_cv = cv2.rotate(image_cv, cv2.ROTATE_90_CLOCKWISE)
+        print("rotation started")
+
+
+        # Save the rotated image to a temporary path
+        # temp_image_path = 'temp_rotated_image.jpg'
+        cv2.imwrite(image_path, image_cv)
+
+        # output=ocr.ocr(temp_image_path)[0]
+        single_img_doc = DocumentFile.from_images(image_path)
+        result=model(single_img_doc)
+        texts=[]
+        for page in result.pages:
+            for block in page.blocks:
+                for line in block.lines:
+                    for word in line.words:
+                        text = word.value
+                        texts.append(text)
+
+        print(texts)
+        r_count+=1
+        if r_count==4:  #reaching the same orientation
+            break
+    
+
+
+    if(r_count>0 and r_count!=4):
+        # cv2.imwrite(image_path,image_cv)
+        print("rotation done for: ",base_name)
+        print("Number of times rotation done:",r_count)
+
+    height = image_cv.shape[0]
+    width = image_cv.shape[1]
+    
+    print("OCR detection done with doctr")
+    boxes=[]
+    # boxes = [line[0] for line in output]4
+    for page in result.pages:
+        for block in page.blocks:
+            for line in block.lines:
+                for word in line.words:
+                   
+                    (x_min, y_min), (x_max, y_max) = word.geometry
+                    
+                    x_min_px = x_min * width
+                    y_min_px = y_min * height
+                    x_max_px = x_max * width
+                    y_max_px = y_max * height
+                    
+                    bbox=(x_min_px, y_min_px), (x_max_px, y_max_px)
+
+                  
+                    boxes.append(bbox)
+
+    image_boxes = image_cv.copy()
+
+
+
+    # print("!------------------------------all coordinates-----------------------------------!")
+
+    for box,text in zip(boxes,texts):
+    #   print(text)
+    #   print(box)
+      cv2.rectangle(image_boxes,(int(box[0][0]),int(box[0][1])),(int(box[1][0]),int(box[1][1])),(0,0,255),5)  #needs top left and bottom right to draw bounding box
+      cv2.putText(image_boxes,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,4,(222,0,0),3)
+    
+    
+    # print("!------------------------------done with all coordinates-----------------------------------!")
+
+
+
+    alldet_file_name = f'detect_{base_name}'
+    alldet_file_path = os.path.join(output_folder1, alldet_file_name)
+    
+    # Save the processed image
+    cv2.imwrite(alldet_file_path, image_boxes)
+  
+
+
+    for box, text in zip(boxes, texts):
+      if text=="SN" or text=="NS":
+        num_l_x1=box[0][0]-100
+        num_r_x1=box[1][0]+140
+    
+        print("left top x of SN:",num_l_x1)
+        print("bottom right x of SN:",num_r_x1)
+       
+
+      if text=="TRUE/FALSE":
+        num_l_x2=box[0][0]-10
+        num_r_x2=box[1][0]+200
+       
+      
+        print("left top x of T/F:",num_l_x2)
+        print("bottom right x of T/F:",num_r_x2)
+
+
+
+
+    
+
+
+    # Draw OCR bounding boxes within the final rectangle
+    cons_boxes_image=image_cv.copy()
+    true_list=[]
+    false_list=[]
+
+
+
+    numbers_dict={}
+    numbers_dict_x={}
+    c=0
+   
+
+    no_of_collisions=0
+    
+    try:
+
+        # this is for s/n column
+        for box, text in zip(boxes, texts):
+            # print(f"the text is : {text}")
+
+        
+            box_top_left_x = int(box[0][0])
+            box_top_left_y=int(box[0][1])
+            box_bottom_right_x = int(box[1][0])
+            box_bottom_right_y = int(box[1][1])
+     
+
+        
+            # print(box_bottom_right_x)
+            # print(box_bottom_right_y)
+            # print(box_width_x)
+            # print(box_width_y)
+
+ 
+        
+            if (num_l_x1 <=  box_bottom_right_x <= num_r_x1 ):
+                if text.isdigit():
+                    number = int(text)
+                    if 1 <= number <= total_questions+1:
+                        # Store in dictionaries only if the number is between 1 and 10
+                        numbers_dict[text] = int(box[0][1])
+                        print(text)
+                        print(box)
+                        # Visualize the rectangle and text on the image (optional)
+                        cv2.rectangle(cons_boxes_image, (int(box[0][0]), int(box[0][1])), (int(box[1][0]), int(box[1][1])), (0, 0, 255), 5)
+                        cv2.putText(cons_boxes_image, text, (int(box[0][0]), int(box[0][1])), cv2.FONT_HERSHEY_SIMPLEX, 1, (222, 0, 0), 1)
+
+
+  
+
+
+
+    
+    
+     
+        
+        prev=0
+
+    
+    
+        for box, text in zip(boxes, texts):
+
+            
+        
+            box_bottom_right_x = int(box[1][0])
+    
+            if(no_of_collisions>4):
+                break
+            
+        # Draw the adjusted bounding box
+            if (num_l_x2 <=  box_bottom_right_x <= num_r_x2):
+                # print("entered in the t/f column ")
+            
+                if label_text(text)==True and text!='TRUE/FALSE':
+                    if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev=box[0][1]
+                        prev_text=text
+                        true_list.append(int(box[0][1]))
+                    else:
+                    
+                        if(abs(box[0][1]-prev)>200):  #to avoid boxes in same row to overlap 
+                            print(text)
+                            print(box)
+                            true_list.append(int(box[0][1]))
+                            prev=box[0][1]
+                            prev_text=text
+                        else:
+                            print(f"collision happend with box:{prev} and text:{prev_text} solving on the basis of percent match boxes")
+                            print("the current box specification are")
+                            print(text)
+                            print(box)
+                            no_of_collisions+=1
+                            ans=percentMatch(prev_text,text)
+                            if(ans==2):
+
+                                if(label_text(prev_text)==False):
+                                    false_list.pop()
+                            
+                                elif(label_text(prev_text)==True):
+                                    true_list.pop()
+                            
+                            
+                                prev=box[0][1]
+                                prev_text=text
+                                true_list.append(int(prev))
+                            
+                            
+                                
+
+                    c+=1
+                
+                elif label_text(text)==False and text!='TRUE/FALSE':
+                    if(c==0):
+                        print("first t/f detection")
+                        print(text)
+                        print(box)
+                        prev=box[0][1]
+                        prev_text=text
+                        false_list.append(int(box[0][1]))
+                    else:
+                        if(abs(box[0][1]-prev)>200):
+                            print(text)
+                            print(box)
+                            false_list.append(int(box[0][1]))
+                            prev=box[0][1]
+                            prev_text=text
+                        else:
+                            print(f"collision happend with box:{prev} and text:{prev_text} solving on the basis of percent match boxes")
+                            print("the current box specification are")
+                            print(text)
+                            print(box)
+                            no_of_collisions+=1
+                            ans=percentMatch(prev_text,text)
+
+                            if(ans==2):
+
+                                if(label_text(prev_text)==False):
+                                    false_list.pop()
+                            
+                                elif(label_text(prev_text)==True):
+                                    true_list.pop()
+                            
+                            
+                                prev=box[0][1]
+                                prev_text=text
+                                false_list.append(int(prev))
+                    c+=1
+
+                cv2.rectangle(cons_boxes_image,(int(box[0][0]),int(box[0][1])),(int(box[1][0]),int(box[1][1])),(0,0,255),5)  
+                cv2.putText(cons_boxes_image,text,(int(box[0][0]),int(box[0][1])),cv2.FONT_HERSHEY_SIMPLEX,1,(222,0,0),1)
+    
+            
+        if(no_of_collisions<=4):
+            final_dict=assign_true_false_or_unknown(true_list,false_list,numbers_dict,total_questions)
+        
+        else:
+            print("going with doctr less gap")
+            cons_boxes_image,final_dict=process_using_doctr_less_row_gap(boxes,texts,numbers_dict,num_l_x2,num_r_x2,image_path,total_questions)
+            
+        
+    
+        # Create a unique output file name
+        output_file_name = f'final_tf_{base_name}'
+        output_file_path = os.path.join(output_folder, output_file_name)
+    
+        # Save the processed image
+        cv2.imwrite(output_file_path, cons_boxes_image)
+
+
+        print("printing the number dict y_coordinate")
+        print(numbers_dict)
+     
+
+
+
+    
+    except NameError:
+
+        print("TRUE/FALSE not detected. Skipping this part of processing.")
+        print("going with paddleocr")
+
+        final_dict=process_using_paddleocr(image_path,output_folder,output_folder1,total_questions)
+
+                
+
+
+    
+        
+
+   
+
+
+
+    
+    print("--------- Printing the final dict ------------")
+    print(final_dict)
+
+    df=pd.DataFrame(final_dict.items(),columns=['Q_No.','True/False'])
+
+    
+    # predcsv_file_name = f'answers_{base_name}.csv'
+
+    # predcsv_file_path = os.path.join(output_folder, predcsv_file_name)
+    # df.to_csv(predcsv_file_path,index=False)
+    
+
+    # print(f'DataFrame saved to {predcsv_file_path}')
+   
+
+
+        
+        
+    
+
+
+
+    # predictions_file_path='pred_output.csv'
+    # reading the answers and evaluting 
+    
+    
+    marks=0
+    w_ans=[]
+    m_ans=[]
+
+    for index, row in actualAns_df.iterrows():
+        question_number = str(row.iloc[0])  # Accessing the first column by index
+        answer = row.iloc[1]  # Accessing the second column by index
+        # print(answer)
+        if final_dict[question_number]==answer:
+            marks += 1
+        elif final_dict[question_number] not in ("NULL", "UNASSIGNED"):
+            w_ans.append(question_number)
+        else:
+            m_ans.append(question_number)
+            
+
+    print("Total Marks:", marks)
+
+    image_name = base_name #Replace this with the actual image name
+    marks_df = pd.DataFrame({"Filename": [image_name], "Marks": [marks]})
+
+    # Append the marks DataFrame to the predictions file
+    # marks_df.to_csv(predictions_file_path, mode='a', header=False, index=False)
+    output_text = f"Marks: {marks} out of {total_questions}"
+
+    if w_ans:
+        output_text += f" and the following were wrong_answers: {w_ans}"
+
+    if m_ans and w_ans:
+        output_text += f" and missed_questions: {m_ans}"
+    
+    if m_ans and len(w_ans)==0:
+        output_text += f" and the following were missed_answers: {m_ans}"
+    
+    print(output_text)
+
+    return output_text
+
+
+
+import gradio as gr
+
+
+output_folder = "test_gradio/output"
+output_folder1 = "test_gradio/detection"
+
+# actual_ans_csv = "test_gradio/ModelAnswer.csv"
+
+demo_image_paths = [
+    "test_gradio/samples/1zHXQVK.jpg",
+    "test_gradio/samples/9X9qVWN.jpg",
+    "test_gradio/samples/LRccyJJ.jpg"
+
+
+]
+
+demo_csv_path = "test_gradio/answerKey.csv"
+
+# Define the Gradio interface
+demo = gr.Interface(
+    fn=lambda img_path, csv_path: process_and_save_image(img_path, csv_path, output_folder, output_folder1),
+    inputs=[gr.Image(type='filepath',label="Upload Image of your answer_sheet"),
+             gr.File(type='filepath',label="Upload the Answer Key in csv file")],
+    outputs=[gr.Textbox(label=f"Predicted Marks")],
+    title="AutoEval for True/False AnswerSheet",
+    examples=[
+        [demo_image_paths[0], demo_csv_path],
+        [demo_image_paths[1], demo_csv_path],
+        [demo_image_paths[2], demo_csv_path]
+    ]
+)   
+
+# Launch the Gradio app
+demo.launch()