update_new_new_new

HTR/app.py

@@ -1,33 +1,99 @@
 import cv2
 import os
 import tempfile
+import logging
+import numpy as np
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 from HTR.word import convert_image
 from HTR.strike import struck_images
 from HTR.hcr import text
 from HTR.spell_and_gramer_check import spell_grammer
 
-# Define a function to extract text from an image
+def preprocess_image(img):
+    """Preprocess image to improve text detection"""
+    try:
+        # Convert to grayscale
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Apply adaptive thresholding
+        binary = cv2.adaptiveThreshold(
+            gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+            cv2.THRESH_BINARY_INV, 11, 2
+        )
+        
+        # Denoise
+        denoised = cv2.fastNlMeansDenoising(binary)
+        
+        # Convert back to BGR
+        return cv2.cvtColor(denoised, cv2.COLOR_GRAY2BGR)
+    except Exception as e:
+        logger.error(f"Error in preprocess_image: {str(e)}")
+        return img
+
 def extract_text_from_image(img_path):
     try:
         # Ensure the image exists
         if not os.path.exists(img_path):
-            raise FileNotFoundError(f"Image file not found: {img_path}")
+            logger.error(f"Image file not found: {img_path}")
+            return ""
             
         # Read the image
         img = cv2.imread(img_path)
         if img is None:
-            raise ValueError(f"Failed to read image: {img_path}")
+            logger.error(f"Failed to read image: {img_path}")
+            return ""
+            
+        # Log image properties
+        logger.info(f"Processing image: {img_path}")
+        logger.info(f"Image shape: {img.shape}")
+        logger.info(f"Image dtype: {img.dtype}")
+        
+        # Convert image to RGB if needed
+        if len(img.shape) == 2:  # If grayscale
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        elif img.shape[2] == 4:  # If RGBA
+            img = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
             
+        # Ensure image is in correct format
+        img = img.astype(np.uint8)
+        
+        # Preprocess image
+        logger.info("Preprocessing image...")
+        img = preprocess_image(img)
+        
         # Process the image
+        logger.info("Converting image...")
         imgs = convert_image(img)
+        if not imgs:
+            logger.error("No text regions detected in image")
+            return ""
+            
+        logger.info(f"Found {len(imgs)} text regions")
+        
+        logger.info("Processing struck images...")
         images_path = struck_images(imgs)
+        if not images_path:
+            logger.error("No valid text regions after strike processing")
+            return ""
+            
+        logger.info("Extracting text...")
         t = text(images_path)
+        if not t:
+            logger.error("No text extracted from image")
+            return ""
+            
+        logger.info("Spell checking...")
         t = spell_grammer(t)
         
+        logger.info(f"Extracted text: {t}")
         return t
+        
     except Exception as e:
-        print(f"Error in extract_text_from_image: {str(e)}")
+        logger.error(f"Error in extract_text_from_image: {str(e)}")
         return ""
 
 # extract_text_from_image("ans_image/1.jpg")

HTR/word.py

@@ -4,7 +4,11 @@ import cv2
 import sys
 import os
 import tempfile
+import logging
 
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 cordinates =[]
      
@@ -38,21 +42,22 @@ def four_point_transform(image, pts):
 
         return warped
     except Exception as e:
-        print(f"Error in four_point_transform: {str(e)}")
+        logger.error(f"Error in four_point_transform: {str(e)}")
         return image
 
 
 def remove_shadow(image):
     try:
         rgb_planes = cv2.split(image)
-
         result_planes = []
         result_norm_planes = []
+        
         for plane in rgb_planes:
             dilated_img = cv2.dilate(plane, np.ones((7,7), np.uint8))
             bg_img = cv2.medianBlur(dilated_img, 21)
             diff_img = 255 - cv2.absdiff(plane, bg_img)
-            norm_img = cv2.normalize(diff_img,None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1)
+            norm_img = cv2.normalize(diff_img, None, alpha=0, beta=255, 
+                                  norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1)
             result_planes.append(diff_img)
             result_norm_planes.append(norm_img)
             
@@ -61,70 +66,58 @@ def remove_shadow(image):
         
         return result, result_norm
     except Exception as e:
-        print(f"Error in remove_shadow: {str(e)}")
+        logger.error(f"Error in remove_shadow: {str(e)}")
         return image, image
 
 
 
     
-def analise(image): 
-    global line, binary_image1, x_scaling , y_scaling
+def analise(image, binary_image1, x_scaling, y_scaling):
     try:
-        kernel = np.ones((1,250),np.uint8)
-     
-        dilation = cv2.dilate(image, kernel, iterations = 2)
-        
-        # cv2.namedWindow("Image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('Image',dilation)
-        # cv2.waitKey(0)
+        line = []
+        kernel = np.ones((1,250), np.uint8)
+        dilation = cv2.dilate(image, kernel, iterations=2)
         
         contours, _ = cv2.findContours(dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
         for i in reversed(contours):
-                x, y, w, h = cv2.boundingRect(i)
-                if cv2.contourArea(i)<20 :
-                    continue
-                elif h < 8:
-                    continue
-                else:
-                    scaling_factor_in_y = 0.5
-                    scaling_factor_in_x = 0
-                    resized_contour = i.copy()
-                    
-                    resized_contour = i * [x_scaling, y_scaling] 
-                    
-                    resized_contour = resized_contour.astype(int)      
-                    final_image__ = np.zeros_like(binary_image1)
-                    cv2.drawContours(final_image__, [resized_contour], 0, (255), -1)
-                                
-                    kernel_dil = np.ones((3,3),np.uint8)
-                    final_image__ = cv2.dilate(final_image__,kernel_dil,iterations = 3)
-                                
-                                
-                    line_image_final = cv2.bitwise_and(final_image__, binary_image1)
-                    line.append(line_image_final)
-                    # cv2.namedWindow("Line image", cv2.WINDOW_NORMAL)   
-                    # cv2.imshow('Line image',line_image_final)
-                    # cv2.waitKey(0)
-      
+            x, y, w, h = cv2.boundingRect(i)
+            if cv2.contourArea(i) < 20 or h < 8:
+                continue
                 
-   
+            scaling_factor_in_y = 0.5
+            scaling_factor_in_x = 0
+            resized_contour = i.copy()
+            
+            resized_contour = i * [x_scaling, y_scaling] 
+            resized_contour = resized_contour.astype(int)      
+            final_image__ = np.zeros_like(binary_image1)
+            cv2.drawContours(final_image__, [resized_contour], 0, (255), -1)
+                        
+            kernel_dil = np.ones((3,3), np.uint8)
+            final_image__ = cv2.dilate(final_image__, kernel_dil, iterations=3)
+                        
+            line_image_final = cv2.bitwise_and(final_image__, binary_image1)
+            line.append(line_image_final)
+            
+        return line
     except Exception as e:
-        print(f"Error in analise: {str(e)}")
-
-def image_resize_and_errosion(image):
-
-    height, width = image.shape[:2]
-    height = height + 1 * height
-    height = int(height)
-    
-    resized_image = cv2.resize(image, (width, height))
-
-    kernel = np.ones((13,1),np.uint8)   
-
-    erosion = cv2.erode(resized_image,kernel,iterations = 1)
+        logger.error(f"Error in analise: {str(e)}")
+        return []
 
-    return erosion
+def image_resize_and_erosion(image):
+    try:
+        height, width = image.shape[:2]
+        height = height + 1 * height
+        height = int(height)
+        
+        resized_image = cv2.resize(image, (width, height))
+        kernel = np.ones((13,1), np.uint8)   
+        erosion = cv2.erode(resized_image, kernel, iterations=1)
+        return erosion
+    except Exception as e:
+        logger.error(f"Error in image_resize_and_erosion: {str(e)}")
+        return image
 
 
 x_scaling = 0
@@ -136,166 +129,122 @@ count = 0
 
 def convert_image(img):
     try:
-        folder_path = 'images'
-
-        for filename in os.listdir(folder_path):
-            file_path = os.path.join(folder_path, filename)
-            try:
-                if os.path.isfile(file_path):
-                    os.remove(file_path)
-            except Exception as e:
-                print(f"Error deleting file {file_path}: {e}")
-        
+        # Create temporary directory for processing
+        temp_dir = tempfile.mkdtemp()
+        images_dir = os.path.join(temp_dir, 'images')
+        os.makedirs(images_dir, exist_ok=True)
         
+        logger.info("Starting image conversion...")
+        logger.info(f"Input image shape: {img.shape}")
         
-        global x_scaling,y_scaling,binary_image1,line,line_lenght,count
-        # img = cv2.imread(image_file)
+        # Ensure image is in correct format
+        if len(img.shape) == 2:  # If grayscale
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        elif img.shape[2] == 4:  # If RGBA
+            img = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
+            
+        img = img.astype(np.uint8)
         img_copy = np.copy(img)
-        line_lenght = 250
+        line_length = 250
         rect_image = img
 
-        # removing the shadow in the image
+        # Remove shadow
+        logger.info("Removing shadow...")
         image1, image2_ = remove_shadow(rect_image)
 
-        # converting into grayscale
-        gray_ = cv2.cvtColor(image2_,cv2.COLOR_BGR2GRAY)
+        # Convert to grayscale
+        logger.info("Converting to grayscale...")
+        gray_ = cv2.cvtColor(image2_, cv2.COLOR_BGR2GRAY)
         
-        # cv2.namedWindow("grayscale image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('grayscale image',gray_)
-        # cv2.waitKey(0)
-
-        # convrting into binaryimage
-        _, binary_image_ = cv2.threshold(gray_, 200, 255, cv2.THRESH_BINARY)
-        # cv2.namedWindow("binary image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('binary image',binary_image_)
-        # cv2.waitKey(0)
-
+        # Convert to binary with adaptive thresholding
+        logger.info("Converting to binary...")
+        binary_image_ = cv2.adaptiveThreshold(
+            gray_, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+            cv2.THRESH_BINARY_INV, 11, 2
+        )
         inverted_binary_image_ = 255 - binary_image_
 
         binary_image1 = np.copy(inverted_binary_image_)
 
-        y_height ,x_width= rect_image.shape[:2]
+        y_height, x_width = rect_image.shape[:2]
+        logger.info(f"Image dimensions: {x_width}x{y_height}")
 
-        # print("image width, height =", x_width, y_height)
-
-        # resizing the image
+        # Resize image
         new_width = 500*5
         new_height = 705*5
 
         x_scaling = x_width/new_width
         y_scaling = y_height/new_height
 
-        # print("After resizing width, height", new_width , new_height)
-        rect_image = cv2.resize(rect_image, (new_width, new_height), interpolation=cv2.INTER_NEAREST)
-        # cv2.namedWindow("resized image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('resized image',rect_image)
-        # cv2.waitKey(0)
+        logger.info("Resizing image...")
+        rect_image = cv2.resize(rect_image, (new_width, new_height), 
+                              interpolation=cv2.INTER_NEAREST)
         
-        # removing the shadow in the image
+        # Process resized image
+        logger.info("Processing resized image...")
         image1, image2 = remove_shadow(rect_image)
-
-        # converting into grayscale
-        gray = cv2.cvtColor(image2,cv2.COLOR_BGR2GRAY)
-        # cv2.namedWindow("grayscale image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('grayscale image',gray)
-        # cv2.waitKey(0)
-        
-        # convrting into binaryimage
-        _, binary_image = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)
-        _, binary_image = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)
-        # cv2.namedWindow("binary image", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('binary image',gray)
-        # cv2.waitKey(0)
-
-        # inverting the pixel
+        gray = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
+        binary_image = cv2.adaptiveThreshold(
+            gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+            cv2.THRESH_BINARY_INV, 11, 2
+        )
         inverted_binary_image = 255 - binary_image
 
-        kernel = np.ones((2,2),np.uint8)
-
-
-        # performing  erosion to remove noise
-        erosion = cv2.erode(inverted_binary_image,kernel,iterations = 1)
-        # cv2.namedWindow("erosion", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('erosion',erosion)
-        # cv2.waitKey(0)
-
-
-        # performing Dilution operatiom
-        dilation = cv2.dilate(erosion,kernel,iterations = 1)
-        # cv2.namedWindow("dilation", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('dilation',erosion)
-        # cv2.waitKey(0)
+        # Apply morphological operations
+        kernel = np.ones((2,2), np.uint8)
+        erosion = cv2.erode(inverted_binary_image, kernel, iterations=1)
+        dilation = cv2.dilate(erosion, kernel, iterations=1)
         
-
         new_image = np.copy(dilation)
         new_image = 255 - new_image 
 
-
-        # defining kernal size
-        kernel = np.ones((1,250),np.uint8)
-
-
-        # performing Dilution operatiom
-        dilation_1 = cv2.dilate(dilation,kernel,iterations = 2)
-        # cv2.namedWindow("dilation_1", cv2.WINDOW_NORMAL)   
-        # cv2.imshow('dilation_1',dilation_1)
-        # cv2.waitKey(0)
+        # Find text regions
+        kernel = np.ones((1,250), np.uint8)
+        dilation_1 = cv2.dilate(dilation, kernel, iterations=2)
         
-        contours, _ = cv2.findContours(dilation_1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        contours, _ = cv2.findContours(dilation_1, cv2.RETR_EXTERNAL, 
+                                     cv2.CHAIN_APPROX_SIMPLE)
         
         line = []
-        # line saparation 
+        logger.info(f"Found {len(contours)} contours")
+        
         for i in reversed(contours):
             x, y, w, h = cv2.boundingRect(i)
-            if cv2.contourArea(i)<20:
-                continue
-            elif h < 10:
+            if cv2.contourArea(i) < 20 or h < 10:
                 continue
-            else:
-                cv2.drawContours(new_image, [i],-1,(0),2)
-                final_image_ = np.zeros_like(binary_image)
-                cv2.drawContours(final_image_, [i], 0, (255), -1)
-                
-                # cv2.namedWindow("final_image_", cv2.WINDOW_NORMAL)   
-                # cv2.imshow('final_image_',final_image_)
-                # cv2.waitKey(0)
-                
-                
-                line_image = cv2.bitwise_and(final_image_, dilation)
-                # cv2.namedWindow("line_image", cv2.WINDOW_NORMAL)   
-                # cv2.imshow('line_image',line_image)
-                # cv2.waitKey(0)
-                
-                            
-                analise(line_image)         
                 
+            cv2.drawContours(new_image, [i], -1, (0), 2)
+            final_image_ = np.zeros_like(binary_image)
+            cv2.drawContours(final_image_, [i], 0, (255), -1)
+            line_image = cv2.bitwise_and(final_image_, dilation)
+            line.extend(analise(line_image, binary_image1, x_scaling, y_scaling))
 
         count = 0
-        kernel1 = np.ones((8,8),np.uint8)
-        word__image = [] # newly added
+        kernel1 = np.ones((8,8), np.uint8)
+        word__image = []
+        
+        logger.info(f"Processing {len(line)} lines")
         for line_image in line:
-                
-            dilation_2 = cv2.dilate(line_image,kernel1,iterations = 2)
-            
-            contours1, _ = cv2.findContours(dilation_2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            
+            dilation_2 = cv2.dilate(line_image, kernel1, iterations=2)
+            contours1, _ = cv2.findContours(dilation_2, cv2.RETR_EXTERNAL, 
+                                          cv2.CHAIN_APPROX_SIMPLE)
             sorted_contours = sorted(contours1, key=lambda c: cv2.boundingRect(c)[0])
             
             for j in sorted_contours:
-                x1,y1,w1,h1 = cv2.boundingRect(j)
-                final_image = line_image[y1:y1+h1,x1:x1+w1]
-                image_name ="images/"+str(count)+".png"
+                x1, y1, w1, h1 = cv2.boundingRect(j)
+                if w1 < 5 or h1 < 5:  # Skip very small regions
+                    continue
+                    
+                final_image = line_image[y1:y1+h1, x1:x1+w1]
                 final_image = 255 - final_image
-                word__image.append(final_image)# newly added
-                # cv2.imwrite(image_name, final_image)
-                count=count+1
+                word__image.append(final_image)
+                count += 1
 
-        # cv2.waitKey(0)
-    #    cv2.destroyAllWindows()
+        logger.info(f"Extracted {count} words")
         return word__image
         
     except Exception as e:
-        print(f"Error in convert_image: {str(e)}")
+        logger.error(f"Error in convert_image: {str(e)}")
         return []
 
     

main.py

@@ -44,14 +44,14 @@ except Exception as e:
 
 # Set up logging to both file and console
 try:
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler(log_file),
-            logging.StreamHandler(sys.stdout)
-        ]
-    )
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(log_file),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
 except Exception as e:
     print(f"Warning: Could not set up file logging: {e}")
     # Fallback to console-only logging
@@ -107,7 +107,7 @@ for data in required_nltk_data:
     try:
         log_print(f"Downloading NLTK data: {data}")
         nltk.download(data, download_dir=nltk_data_dir)
-    except Exception as e:
+except Exception as e:
         log_print(f"Error downloading NLTK data {data}: {e}", "ERROR")
         raise
 
@@ -155,11 +155,11 @@ def compute_answers():
             return jsonify({"error": "Missing query file"}), 400
         
         try:
-            queries = query_file.read().decode('utf-8').splitlines()
+        queries = query_file.read().decode('utf-8').splitlines()
             if not queries:
                 log_print("No queries found in file", "ERROR")
                 return jsonify({"error": "No queries found in file"}), 400
-            log_print(f"Received queries: {queries}")
+        log_print(f"Received queries: {queries}")
         except UnicodeDecodeError:
             log_print("Invalid file encoding", "ERROR")
             return jsonify({"error": "Invalid file encoding"}), 400
@@ -177,12 +177,12 @@ def compute_answers():
                 return jsonify({"error": "Missing answer CSV file"}), 400
                 
             try:
-                ans_csv_file = ans_csv_file.read().decode('utf-8').splitlines()
-                c_answers = []
-                for i in ans_csv_file:
-                    c_answers.append(i.split('\\n'))
-                log_print(f"Processed CSV answers: {c_answers}")
-                return jsonify({"answers": c_answers}), 200
+            ans_csv_file = ans_csv_file.read().decode('utf-8').splitlines()
+            c_answers = []
+            for i in ans_csv_file:
+                c_answers.append(i.split('\\n'))
+            log_print(f"Processed CSV answers: {c_answers}")
+            return jsonify({"answers": c_answers}), 200
             except UnicodeDecodeError:
                 log_print("Invalid CSV file encoding", "ERROR")
                 return jsonify({"error": "Invalid CSV file encoding"}), 400
@@ -253,14 +253,14 @@ def compute_marks():
             return jsonify({"error": "No answers provided"}), 400
         
         try:
-            log_print("=== Processing Answers ===")
-            log_print(f"Received answers: {a}")
-            a = json.loads(a)
-            answers = []
-            for i in a:
-                ans = i.split('\n\n')
-                answers.append(ans)
-            log_print(f"Processed answers structure: {answers}")
+        log_print("=== Processing Answers ===")
+        log_print(f"Received answers: {a}")
+        a = json.loads(a)
+        answers = []
+        for i in a:
+            ans = i.split('\n\n')
+            answers.append(ans)
+        log_print(f"Processed answers structure: {answers}")
         except json.JSONDecodeError:
             log_print("Invalid JSON format in answers", "ERROR")
             return jsonify({"error": "Invalid JSON format in answers"}), 400
@@ -378,7 +378,7 @@ def compute_marks():
         log_print("\nFinal Results:")
         for student, marks_list in s_marks.items():
             log_print(f"{student}: {marks_list}")
-
+            
         return jsonify({"message": s_marks}), 200
 
     except Exception as e: