fix the htr

HTR/app.py

@@ -70,7 +70,10 @@ def extract_text_from_image(img_path):
         imgs = convert_image(img)
         if not imgs:
             logger.error("No text regions detected in image")
-            return ""
+            # Try processing the whole image as one region
+            temp_path = os.path.join(tempfile.gettempdir(), 'whole_image.png')
+            cv2.imwrite(temp_path, img)
+            imgs = [temp_path]
             
         logger.info(f"Found {len(imgs)} text regions")
         

HTR/hcr.py

@@ -26,15 +26,36 @@ def text(image_cv):
         # Initialize model if not already done
         initialize_model()
         
+        if not isinstance(image_cv, list):
+            image_cv = [image_cv]
+            
         t = ""
         for i in image_cv:
             try:
+                # Ensure image is in correct format
+                if isinstance(i, str):
+                    # If i is a path, read the image
+                    i = cv2.imread(i)
+                    if i is None:
+                        print(f"Failed to read image")
+                        continue
+                
                 # Convert BGR to RGB
                 img_rgb = cv2.cvtColor(i, cv2.COLOR_BGR2RGB)
+                
+                # Convert numpy array to PIL Image
                 image = Image.fromarray(img_rgb)
                 
+                # Resize if image is too small
+                min_size = 224  # minimum size required by the model
+                if image.size[0] < min_size or image.size[1] < min_size:
+                    ratio = max(min_size/image.size[0], min_size/image.size[1])
+                    new_size = tuple([int(dim * ratio) for dim in image.size])
+                    image = image.resize(new_size, Image.Refilter.LANCZOS)
+                
                 # Process image
                 pixel_values = processor(image, return_tensors="pt").pixel_values
+                
                 if torch.cuda.is_available():
                     pixel_values = pixel_values.to('cuda')
                 
@@ -43,7 +64,7 @@ def text(image_cv):
                 t = t + generated_text.replace(" ", "") + " "
                 
             except Exception as e:
-                print(f"Error processing image: {str(e)}")
+                print(f"Error processing individual image: {str(e)}")
                 continue
                 
         return t.strip()

main.py

@@ -264,6 +264,7 @@ def compute_marks():
         
         # Dictionary to store results by student folder
         results = {}
+        failed_files = []  # Track failed files
         
         # Process each file
         for file in files:
@@ -290,48 +291,72 @@ def compute_marks():
                 filepath = os.path.join(student_dir, filename)
                 file.save(filepath)
                 
-                # Extract text from image
-                extracted_text = extract_text_from_image(filepath)
-                
-                if not extracted_text:
-                    log_print(f"No text extracted from {file.filename}", "WARNING")
-                    continue
+                try:
+                    # Extract text from image with better error handling
+                    extracted_text = extract_text_from_image(filepath)
                     
-                # Find which answer this matches best
-                best_score = 0
-                best_answer_index = 0
-                
-                # Compare with each correct answer
-                for i, correct_answer in enumerate(correct_answers):
-                    # Calculate different similarity scores
-                    semantic_score = question_vector_sentence(extracted_text, correct_answer)
-                    word_score = question_vector_word(extracted_text, correct_answer)
-                    tfidf_score = tfidf_answer_score(extracted_text, correct_answer)
-                    ft_score = fasttext_similarity(extracted_text, correct_answer)
-                    llm_marks = llm_score(extracted_text, correct_answer)
+                    if not extracted_text or len(extracted_text.strip()) == 0:
+                        log_print(f"No valid text extracted from {file.filename}", "WARNING")
+                        failed_files.append({
+                            "file": file.filename,
+                            "error": "No text could be extracted"
+                        })
+                        continue
+                        
+                    log_print(f"Successfully extracted text from {file.filename}: {extracted_text[:100]}...")
                     
-                    # Combine scores with weights
-                    combined_score = (
-                        semantic_score * 0.3 +
-                        word_score * 0.2 +
-                        tfidf_score * 0.2 +
-                        ft_score * 0.2 +
-                        llm_marks * 0.1
-                    )
+                    # Find which answer this matches best
+                    best_score = 0
+                    best_answer_index = 0
                     
-                    # Update if this is the best matching answer
-                    if combined_score > best_score:
-                        best_score = combined_score
-                        best_answer_index = i
-                
-                # Scale the score to 0-5 range
-                marks = new_value(best_score, 0, 1, 0, 5)
-                
-                # Update the student's score for this answer
-                results[student_folder][best_answer_index] = round(marks, 2)
+                    # Compare with each correct answer
+                    for i, correct_answer in enumerate(correct_answers):
+                        try:
+                            # Calculate different similarity scores with error handling
+                            semantic_score = question_vector_sentence(extracted_text, correct_answer)
+                            word_score = question_vector_word(extracted_text, correct_answer)
+                            tfidf_score = tfidf_answer_score(extracted_text, correct_answer)
+                            ft_score = fasttext_similarity(extracted_text, correct_answer)
+                            llm_marks = llm_score(extracted_text, correct_answer)
+                            
+                            # Combine scores with weights
+                            combined_score = (
+                                semantic_score * 0.3 +
+                                word_score * 0.2 +
+                                tfidf_score * 0.2 +
+                                ft_score * 0.2 +
+                                llm_marks * 0.1
+                            )
+                            
+                            # Update if this is the best matching answer
+                            if combined_score > best_score:
+                                best_score = combined_score
+                                best_answer_index = i
+                                
+                        except Exception as score_error:
+                            log_print(f"Error calculating scores for {file.filename}: {str(score_error)}", "ERROR")
+                            continue
+                    
+                    # Scale the score to 0-5 range
+                    marks = new_value(best_score, 0, 1, 0, 5)
+                    
+                    # Update the student's score for this answer
+                    results[student_folder][best_answer_index] = round(marks, 2)
+                    
+                except Exception as extract_error:
+                    log_print(f"Error extracting text from {file.filename}: {str(extract_error)}", "ERROR")
+                    failed_files.append({
+                        "file": file.filename,
+                        "error": str(extract_error)
+                    })
+                    continue
                 
             except Exception as e:
                 log_print(f"Error processing file {file.filename}: {str(e)}", "ERROR")
+                failed_files.append({
+                    "file": file.filename,
+                    "error": str(e)
+                })
                 continue
                 
         # Clean up
@@ -345,7 +370,10 @@ def compute_marks():
             return jsonify({"error": "No results computed"}), 400
             
         log_print(f"Computed marks for {len(results)} students")
-        return jsonify({"results": results}), 200
+        return jsonify({
+            "results": results,
+            "failed_files": failed_files  # Include failed files in response
+        }), 200
         
     except Exception as e:
         log_print(f"Error computing marks: {str(e)}", "ERROR")
@@ -360,10 +388,18 @@ def check_logs():
     except Exception as e:
         return jsonify({"error": str(e)})
 
-# Add file type validation
 def is_valid_image_file(filename):
-    valid_extensions = {'.jpg', '.jpeg', '.png'}
-    return os.path.splitext(filename)[1].lower() in valid_extensions
+    """Validate image file extensions and basic format"""
+    try:
+        # Check file extension
+        valid_extensions = {'.jpg', '.jpeg', '.png'}
+        ext = os.path.splitext(filename)[1].lower()
+        if ext not in valid_extensions:
+            return False
+            
+        return True
+    except Exception:
+        return False
 
 def allowed_file(filename, allowed_extensions):
     return '.' in filename and \