printing extracted text6

HTR/app.py

@@ -56,84 +56,72 @@ def preprocess_image(img):
 
 def extract_text_from_image(img_path):
     try:
+        # Log start of text extraction
+        log_print(f"Starting text extraction for image: {img_path}")
+        
         # Ensure the image exists
         if not os.path.exists(img_path):
+            error_msg = f"Image file not found: {img_path}"
+            log_print(error_msg, "ERROR")
             notification_queue.put({
                 "type": "error",
-                "message": f"Image file not found: {img_path}"
+                "message": error_msg
             })
             return ""
             
         # Read the image
-        notification_queue.put({
-            "type": "info",
-            "message": f"Reading image: {os.path.basename(img_path)}"
-        })
+        log_print(f"Reading image: {os.path.basename(img_path)}")
         img = cv2.imread(img_path)
         if img is None:
+            error_msg = f"Failed to read image: {img_path}"
+            log_print(error_msg, "ERROR")
             notification_queue.put({
                 "type": "error",
-                "message": f"Failed to read image: {img_path}"
+                "message": error_msg
             })
             return ""
             
         # Log image properties
-        notification_queue.put({
-            "type": "info",
-            "message": f"Processing image: {os.path.basename(img_path)}\nImage shape: {img.shape}\nImage type: {img.dtype}"
-        })
+        log_print(f"Image properties - Shape: {img.shape}, Type: {img.dtype}")
         
         # Process the image
-        notification_queue.put({
-            "type": "info",
-            "message": "Converting image to text regions..."
-        })
+        log_print("Converting image to text regions...")
         imgs = convert_image(img)
         if not imgs:
-            notification_queue.put({
-                "type": "warning",
-                "message": "No text regions detected in image. Processing whole image..."
-            })
+            log_print("No text regions detected, processing whole image...", "WARNING")
             # 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]
             
-        notification_queue.put({
-            "type": "info",
-            "message": f"Found {len(imgs)} text regions"
-        })
+        log_print(f"Found {len(imgs)} text regions")
         
-        notification_queue.put({
-            "type": "info",
-            "message": "Processing text regions..."
-        })
+        log_print("Processing text regions...")
         images_path = struck_images(imgs)
         if not images_path:
+            error_msg = "No valid text regions after processing"
+            log_print(error_msg, "ERROR")
             notification_queue.put({
                 "type": "error",
-                "message": "No valid text regions after processing"
+                "message": error_msg
             })
             return ""
             
-        notification_queue.put({
-            "type": "info",
-            "message": "Extracting text from regions..."
-        })
+        log_print("Extracting text from regions...")
         t = text(images_path)
         if not t:
+            error_msg = "No text could be extracted from image"
+            log_print(error_msg, "ERROR")
             notification_queue.put({
                 "type": "error",
-                "message": "No text could be extracted from image"
+                "message": error_msg
             })
             return ""
             
-        notification_queue.put({
-            "type": "info",
-            "message": "Performing spell checking..."
-        })
+        log_print("Performing spell checking...")
         t = spell_grammer(t)
         
+        log_print(f"Successfully extracted text: {t}")
         notification_queue.put({
             "type": "success",
             "message": "Text extraction complete",
@@ -144,10 +132,11 @@ def extract_text_from_image(img_path):
         return t
         
     except Exception as e:
-        error_msg = str(e)
+        error_msg = f"Error in text extraction: {str(e)}"
+        log_print(error_msg, "ERROR")
         notification_queue.put({
             "type": "error",
-            "message": f"Error in text extraction: {error_msg}"
+            "message": error_msg
         })
         return ""
 

HTR/hcr.py

@@ -32,33 +32,65 @@ def text(image_cv):
     try:
         # Initialize model if not already initialized
         if processor is None or model is None:
+            log_print("TrOCR model not initialized, initializing now...")
             initialize_model()
             
+        if processor is None or model is None:
+            raise RuntimeError("Failed to initialize TrOCR model")
+            
         if not isinstance(image_cv, list):
             image_cv = [image_cv]
             
         t = ""
         total_images = len(image_cv)
-        notification_queue.put({
-            "type": "info",
-            "message": f"Processing {total_images} image(s)..."
-        })
-        for i in image_cv:
-            img_rgb = cv2.cvtColor(i, cv2.COLOR_BGR2RGB)
-            image = Image.fromarray(img_rgb)
-
-            pixel_values = processor(image, return_tensors="pt").pixel_values
-            generated_ids = model.generate(pixel_values)
-
-            generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-            t = t + generated_text.replace(" ", "") + " "
-        return t
+        log_print(f"Processing {total_images} image(s) for text extraction")
+        
+        for i, img in enumerate(image_cv):
+            try:
+                log_print(f"Processing image {i+1}/{total_images}")
+                
+                # Validate image
+                if img is None:
+                    log_print(f"Skipping image {i+1} - Image is None", "WARNING")
+                    continue
+                    
+                # Convert to RGB
+                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                image = Image.fromarray(img_rgb)
+                
+                # Get pixel values
+                pixel_values = processor(image, return_tensors="pt").pixel_values
+                if torch.cuda.is_available():
+                    pixel_values = pixel_values.to('cuda')
+                    
+                # Generate text
+                generated_ids = model.generate(pixel_values)
+                generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+                
+                # Clean up the text
+                cleaned_text = generated_text.replace(" ", "")
+                t = t + cleaned_text + " "
+                
+                log_print(f"Successfully extracted text from image {i+1}: {cleaned_text}")
+                
+                # Clean up CUDA memory
+                if torch.cuda.is_available():
+                    del pixel_values
+                    del generated_ids
+                    torch.cuda.empty_cache()
+                    
+            except Exception as e:
+                log_print(f"Error processing image {i+1}: {str(e)}", "ERROR")
+                continue
+                
+        return t.strip()
         
     except Exception as e:
-        error_msg = str(e)
+        error_msg = f"Error in text function: {str(e)}"
+        log_print(error_msg, "ERROR")
         notification_queue.put({
             "type": "error",
-            "message": f"Error in text function: {error_msg}"
+            "message": error_msg
         })
         return ""
     

main.py

@@ -572,7 +572,8 @@ def compute_marks():
                     logger.info(f"Processing student: {student}, image: {filename}")
                     logger.info(f"Extracted text: {s_answer}")
                     
-                    if not s_answer:
+                    # Handle case where text extraction fails
+                    if s_answer is None or s_answer.strip() == '':
                         logger.warning(f"No text extracted from {image_path}")
                         results.append({
                             "subfolder": student,
@@ -580,7 +581,7 @@ def compute_marks():
                             "marks": 0,
                             "extracted_text": "",
                             "correct_answer": answers[count],
-                            "error": "No text could be extracted from image"
+                            "error": "No text could be extracted from image. Please check image quality."
                         })
                         count += 1
                         continue
@@ -617,7 +618,7 @@ def compute_marks():
                         "marks": 0,
                         "extracted_text": "",
                         "correct_answer": answers[count] if count < len(answers) else [],
-                        "error": str(e)
+                        "error": f"Error processing image: {str(e)}"
                     })
                     count += 1
                     continue
@@ -638,7 +639,8 @@ def compute_marks():
             "debug_info": {
                 "total_students": len(data),
                 "total_answers": len(answers),
-                "answers_processed": count
+                "answers_processed": count,
+                "successful_extractions": len([r for r in results if r.get('extracted_text')])
             }
         }), 200
         

templates/2.html

@@ -782,6 +782,29 @@
             font-family: monospace;
             line-height: 1.5;
         }
+
+        /* Add these styles if not already present */
+        .log-entry {
+            padding: 5px;
+            margin: 2px 0;
+            border-radius: 4px;
+        }
+        .log-info {
+            background-color: #e3f2fd;
+            color: #0d47a1;
+        }
+        .log-error {
+            background-color: #ffebee;
+            color: #c62828;
+        }
+        .log-warning {
+            background-color: #fff3e0;
+            color: #ef6c00;
+        }
+        .log-success {
+            background-color: #e8f5e9;
+            color: #2e7d32;
+        }
     </style>
 </head>
 <body>
@@ -905,6 +928,19 @@
         </div>
     </div>
 
+    <!-- Add this right after your existing modal -->
+    <div id="logModal" class="modal">
+        <div class="modal-content" style="width: 80%; max-height: 80vh; margin: 5% auto;">
+            <div class="modal-header">
+                <h2>Processing Logs</h2>
+                <span class="close" onclick="document.getElementById('logModal').style.display='none'">&times;</span>
+            </div>
+            <div class="modal-body" style="max-height: 60vh; overflow-y: auto;">
+                <pre id="logContent" style="white-space: pre-wrap; word-wrap: break-word; font-family: monospace; line-height: 1.5;"></pre>
+            </div>
+        </div>
+    </div>
+
     <script>
         const notificationSystem = {
             container: null,
@@ -1486,51 +1522,56 @@
                 groupedResults[result.subfolder].push(result);
             });
 
-            // Create summary section
+            // Calculate statistics
+            const totalStudents = Object.keys(groupedResults).length;
+            const totalAnswers = results.length;
+            const successfulExtractions = results.filter(r => r.extracted_text && !r.error).length;
+            const failedExtractions = results.filter(r => !r.extracted_text || r.error).length;
+
+            // Create summary section with more detailed information
             const summarySection = document.createElement('div');
             summarySection.className = 'marks-summary';
             summarySection.innerHTML = `
                 <h4>Processing Summary</h4>
-                <p>Total students processed: ${Object.keys(groupedResults).length}</p>
-                <p>Total answers evaluated: ${results.length}</p>
-            `;
-            
-            // Update table headers to include the View Text column
-            const table = document.getElementById('marks-table');
-            table.querySelector('thead tr').innerHTML = `
-                <th>Student Folder</th>
-                <th>Image Name</th>
-                <th>Marks</th>
-                <th>Actions</th>
+                <p>Total students processed: ${totalStudents}</p>
+                <p>Total answers evaluated: ${totalAnswers}</p>
+                <p>Successful text extractions: ${successfulExtractions}</p>
+                <p>Failed text extractions: ${failedExtractions}</p>
+                ${failedExtractions > 0 ? '<p style="color: #721c24;">⚠️ Some text extractions failed. Click "View Text" to see details.</p>' : ''}
             `;
             
-            // Insert summary before the table
-            const tableContainer = document.getElementById('marks-table-container');
-            tableContainer.insertBefore(summarySection, tableContainer.firstChild);
-
             // Display results in table
             Object.entries(groupedResults).forEach(([subfolder, folderResults]) => {
                 folderResults.forEach(result => {
                     const row = document.createElement('tr');
                     row.innerHTML = `
-                        <td>${result.subfolder}</td>
-                        <td>${result.image}</td>
-                        <td>${result.marks.toFixed(2)}</td>
+                        <td>${escapeHtml(result.subfolder)}</td>
+                        <td>${escapeHtml(result.image)}</td>
+                        <td>
+                            ${result.error ? 
+                                `<span style="color: #721c24;">0.00 ⚠️</span>` : 
+                                result.marks.toFixed(2)}
+                        </td>
                         <td>
                             <button class="view-text-btn" onclick='showTextModal(${JSON.stringify({
                                 extracted_text: result.extracted_text,
                                 correct_answer: result.correct_answer,
                                 marks: result.marks,
                                 image: result.image,
-                                subfolder: result.subfolder
+                                subfolder: result.subfolder,
+                                error: result.error
                             })})'>
-                                View Text
+                                ${result.error ? 'View Error' : 'View Text'}
                             </button>
                         </td>
                     `;
                     tableBody.appendChild(row);
                 });
             });
+            
+            // Insert summary before the table
+            const tableContainer = document.getElementById('marks-table-container');
+            tableContainer.insertBefore(summarySection, tableContainer.firstChild);
         }
 
         function showTextModal(result) {
@@ -1539,19 +1580,23 @@
             const correctAnswer = document.getElementById('correctAnswer');
             
             // Handle extracted text
-            if (result.extracted_text === undefined || result.extracted_text === null || result.extracted_text.trim() === '') {
+            if (result.error) {
+                // If there's an error, display it with the error styling
+                extractedText.innerHTML = `<span style="color: #721c24; background-color: #f8d7da; padding: 10px; border-radius: 4px; display: block;">${result.error}</span>`;
+            } else if (!result.extracted_text || result.extracted_text.trim() === '') {
                 extractedText.innerHTML = '<span style="color: #721c24; background-color: #f8d7da; padding: 10px; border-radius: 4px; display: block;">No text could be extracted from the image. This might be due to poor image quality or unreadable handwriting.</span>';
             } else {
-                extractedText.textContent = result.extracted_text;
+                extractedText.innerHTML = `<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0; font-family: monospace; line-height: 1.5;">${escapeHtml(result.extracted_text)}</pre>`;
             }
             
             // Handle correct answer
             if (!result.correct_answer || (Array.isArray(result.correct_answer) && result.correct_answer.length === 0)) {
                 correctAnswer.innerHTML = '<span style="color: #856404; background-color: #fff3cd; padding: 10px; border-radius: 4px; display: block;">No correct answer available. Please ensure you have generated answers first.</span>';
             } else {
-                correctAnswer.textContent = Array.isArray(result.correct_answer) 
+                const formattedAnswer = Array.isArray(result.correct_answer) 
                     ? result.correct_answer.filter(ans => ans && ans.trim() !== '').join('\n\n')
                     : result.correct_answer;
+                correctAnswer.innerHTML = `<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0; font-family: monospace; line-height: 1.5;">${escapeHtml(formattedAnswer)}</pre>`;
             }
             
             // Add additional information if available
@@ -1565,8 +1610,8 @@
                     <h4>Additional Information</h4>
                     <p style="font-family: sans-serif;">
                         ${result.marks !== undefined ? `<strong>Marks:</strong> ${result.marks.toFixed(2)}<br>` : ''}
-                        ${result.image ? `<strong>Image:</strong> ${result.image}<br>` : ''}
-                        ${result.subfolder ? `<strong>Student Folder:</strong> ${result.subfolder}` : ''}
+                        ${result.image ? `<strong>Image:</strong> ${escapeHtml(result.image)}<br>` : ''}
+                        ${result.subfolder ? `<strong>Student Folder:</strong> ${escapeHtml(result.subfolder)}` : ''}
                     </p>
                 `;
                 
@@ -1582,13 +1627,22 @@
                 correct_answer: result.correct_answer,
                 marks: result.marks,
                 image: result.image,
-                subfolder: result.subfolder
+                subfolder: result.subfolder,
+                error: result.error
             });
             
             // Show the modal
             modal.style.display = 'block';
         }
 
+        // Helper function to escape HTML special characters
+        function escapeHtml(text) {
+            if (!text) return '';
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
         function closeModal() {
             const modal = document.getElementById('textModal');
             modal.style.display = 'none';
@@ -1727,6 +1781,120 @@
         window.addEventListener('beforeunload', function() {
             stopLogRefresh();
         });
+
+        // Add this to your existing JavaScript
+        let logMessages = [];
+
+        function addLogMessage(message, type = 'info') {
+            const logContent = document.getElementById('logContent');
+            const entry = document.createElement('div');
+            entry.className = `log-entry log-${type.toLowerCase()}`;
+            entry.textContent = message;
+            logContent.appendChild(entry);
+            logContent.scrollTop = logContent.scrollHeight;
+            
+            // Keep only last 100 messages
+            logMessages.push({ message, type });
+            if (logMessages.length > 100) {
+                logMessages.shift();
+                // Remove first child from logContent
+                if (logContent.firstChild) {
+                    logContent.removeChild(logContent.firstChild);
+                }
+            }
+        }
+
+        function showLogModal() {
+            document.getElementById('logModal').style.display = 'block';
+        }
+
+        // Update your existing event source handling
+        if (typeof eventSource !== 'undefined') {
+            eventSource.close();
+        }
+
+        eventSource = new EventSource('/notifications');
+        eventSource.onmessage = function(event) {
+            const data = JSON.parse(event.data);
+            if (data.type === 'ping') return;
+            
+            // Add message to log modal
+            if (data.message) {
+                let type = data.type;
+                if (typeof data.message === 'object' && data.message.message) {
+                    addLogMessage(data.message.message, type);
+                } else {
+                    addLogMessage(data.message, type);
+                }
+            }
+            
+            // Show notification
+            if (data.type === 'error') {
+                showError(data.message);
+            } else if (data.type === 'success') {
+                showSuccess(data.message);
+            } else if (data.type === 'info') {
+                showInfo(data.message);
+            }
+        };
+
+        // Update your compute_marks function
+        async function computeMarks() {
+            try {
+                // Show log modal
+                showLogModal();
+                addLogMessage("Starting marks computation...", "info");
+                
+                // ... rest of your existing compute_marks code ...
+                
+                const formData = new FormData();
+                formData.append('answers', JSON.stringify(answers));
+                
+                // Append files
+                const files = document.getElementById('file').files;
+                for (let i = 0; i < files.length; i++) {
+                    formData.append('file', files[i]);
+                }
+                
+                addLogMessage("Uploading files and computing marks...", "info");
+                
+                const response = await fetch('/compute_marks', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                
+                const result = await response.json();
+                if (result.error) {
+                    addLogMessage(`Error: ${result.error}`, "error");
+                    throw new Error(result.error);
+                }
+                
+                addLogMessage("Successfully computed marks!", "success");
+                displayMarks(result.results);
+                
+            } catch (error) {
+                addLogMessage(`Error: ${error.message}`, "error");
+                showError(error.message);
+            }
+        }
+
+        // Update your compute_answers function similarly
+        async function computeAnswers() {
+            try {
+                showLogModal();
+                addLogMessage("Starting answer computation...", "info");
+                
+                // ... rest of your existing compute_answers code ...
+                
+            } catch (error) {
+                addLogMessage(`Error: ${error.message}`, "error");
+                showError(error.message);
+            }
+        }
     </script>
 </body>
 </html>

utils.py

@@ -1,6 +1,7 @@
 import queue
 import logging
 import sys
+from datetime import datetime
 
 # Create notification queue
 notification_queue = queue.Queue()
@@ -14,9 +15,30 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 def log_print(message, level="INFO"):
-    if level == "INFO":
-        logger.info(message)
-    elif level == "ERROR":
-        logger.error(message)
-    elif level == "WARNING":
-        logger.warning(message)
+    """
+    Log a message both to the console and send it to the frontend via notification queue
+    
+    Args:
+        message (str): The message to log
+        level (str): The log level (INFO, WARNING, ERROR, SUCCESS)
+    """
+    # Get timestamp
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Log to console
+    print(f"[{timestamp}] {level}: {message}")
+    
+    # Map log level to notification type
+    type_map = {
+        "INFO": "info",
+        "WARNING": "warning",
+        "ERROR": "error",
+        "SUCCESS": "success"
+    }
+    
+    # Send to frontend via notification queue
+    notification_queue.put({
+        "type": type_map.get(level, "info"),
+        "message": f"{message}",
+        "timestamp": timestamp
+    })