Update ocr_engine.py

ocr_engine.py

@@ -6,7 +6,7 @@ import logging
 from datetime import datetime
 import os
 
-# Set up logging for debugging
+# Set up logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Initialize EasyOCR
@@ -17,147 +17,98 @@ DEBUG_DIR = "debug_images"
 os.makedirs(DEBUG_DIR, exist_ok=True)
 
 def save_debug_image(img, filename_suffix, prefix=""):
-    """Saves an image to the debug directory with a timestamp."""
+    """Save image to debug directory with timestamp."""
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
     filename = os.path.join(DEBUG_DIR, f"{prefix}{timestamp}_{filename_suffix}.png")
-    if len(img.shape) == 3:  # Color image
+    if len(img.shape) == 3:
         cv2.imwrite(filename, img)
-    else:  # Grayscale image
+    else:
         cv2.imwrite(filename, img)
     logging.info(f"Saved debug image: {filename}")
 
 def estimate_brightness(img):
-    """Estimate image brightness to detect illuminated displays."""
+    """Estimate image brightness."""
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     return np.mean(gray)
 
-def preprocess_image(img, scale=1.0, method='clahe'):
-    """Preprocess image for better OCR accuracy."""
-    if scale != 1.0:
-        img = cv2.resize(img, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
-        save_debug_image(img, f"01_preprocess_scaled_{scale}")
+def preprocess_image(img):
+    """Preprocess image for OCR."""
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    # Gentle denoising
-    denoised = cv2.bilateralFilter(gray, 7, 10, 10)
-    save_debug_image(denoised, "02_preprocess_bilateral")
-    # Enhance contrast
-    if method == 'clahe':
-        clahe = cv2.createCLAHE(clipLimit=3.5, tileGridSize=(8, 8))
-        enhanced = clahe.apply(denoised)
-    else:  # Histogram equalization
-        enhanced = cv2.equalizeHist(denoised)
-    save_debug_image(enhanced, f"03_preprocess_{method}")
-    # Sharpen
-    kernel_sharpening = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
-    sharpened = cv2.filter2D(enhanced, -1, kernel_sharpening)
-    save_debug_image(sharpened, "04_preprocess_sharpened")
-    return sharpened
+    denoised = cv2.bilateralFilter(gray, 5, 8, 8)
+    save_debug_image(denoised, "01_preprocess_bilateral")
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    enhanced = clahe.apply(denoised)
+    save_debug_image(enhanced, "02_preprocess_clahe")
+    return enhanced
 
 def correct_rotation(img):
-    """Correct image rotation using Hough Transform."""
+    """Correct image rotation."""
     try:
         edges = cv2.Canny(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 50, 150)
-        lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=50, minLineLength=40, maxLineGap=10)
+        lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=50, minLineLength=30, maxLineGap=10)
         if lines is not None:
             angles = [np.arctan2(line[0][3] - line[0][1], line[0][2] - line[0][0]) * 180 / np.pi for line in lines]
             angle = np.median(angles)
             if abs(angle) > 2:
-                (h, w) = img.shape[:2]
+                h, w = img.shape[:2]
                 center = (w // 2, h // 2)
                 M = cv2.getRotationMatrix2D(center, angle, 1.0)
                 img = cv2.warpAffine(img, M, (w, h))
                 save_debug_image(img, "00_rotated_image")
-                logging.info(f"Applied rotation correction: {angle:.2f} degrees")
+                logging.info(f"Applied rotation: {angle:.2f} degrees")
         return img
     except Exception as e:
         logging.error(f"Rotation correction failed: {str(e)}")
         return img
 
 def detect_roi(img):
-    """Detect and crop the region of interest (likely the digital display)."""
+    """Detect region of interest (display)."""
     try:
-        save_debug_image(img, "05_original")
-        brightness_map = cv2.GaussianBlur(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), (15, 15), 0)
-        
-        # Try multiple scales and methods
-        scales = [1.0, 1.5, 0.5]
-        methods = ['clahe', 'hist']
-        for scale in scales:
-            for method in methods:
-                preprocessed = preprocess_image(img, scale, method)
-                block_size = max(9, min(31, int(img.shape[0] / 25) * 2 + 1))
-                thresh = cv2.adaptiveThreshold(preprocessed, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                               cv2.THRESH_BINARY_INV, block_size, 3)
-                _, otsu_thresh = cv2.threshold(preprocessed, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-                combined_thresh = cv2.bitwise_and(thresh, otsu_thresh)
-                save_debug_image(combined_thresh, f"06_roi_combined_threshold_scale_{scale}_{method}")
-                
-                # Morphological operations
-                kernel = np.ones((3, 3), np.uint8)
-                dilated = cv2.dilate(combined_thresh, kernel, iterations=2)
-                eroded = cv2.erode(dilated, kernel, iterations=1)
-                save_debug_image(eroded, f"07_roi_morphological_scale_{scale}_{method}")
-                
-                contours, _ = cv2.findContours(eroded, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-                
-                if contours:
-                    img_area = img.shape[0] * img.shape[1]
-                    valid_contours = []
-                    for c in contours:
-                        area = cv2.contourArea(c)
-                        x, y, w, h = cv2.boundingRect(c)
-                        roi_brightness = np.mean(brightness_map[y:y+h, x:x+w] if scale == 1.0 else cv2.resize(brightness_map, (img.shape[1], img.shape[0])))
-                        aspect_ratio = w / h
-                        if (100 < area < (img_area * 0.95) and 
-                            0.3 <= aspect_ratio <= 20.0 and w > 40 and h > 15 and roi_brightness > 50):
-                            valid_contours.append((c, roi_brightness))
-                            logging.debug(f"Contour: Scale={scale}, Method={method}, Area={area}, Aspect={aspect_ratio:.2f}, Brightness={roi_brightness:.2f}")
-                    
-                    if valid_contours:
-                        contour, _ = max(valid_contours, key=lambda x: x[1])
-                        x, y, w, h = cv2.boundingRect(contour)
-                        if scale != 1.0:
-                            x, y, w, h = [int(v / scale) for v in (x, y, w, h)]
-                        padding = 150
-                        x, y = max(0, x - padding), max(0, y - padding)
-                        w, h = min(w + 2 * padding, img.shape[1] - x), min(h + 2 * padding, img.shape[0] - y)
-                        roi_img = img[y:y+h, x:x+w]
-                        save_debug_image(roi_img, f"08_detected_roi_scale_{scale}_{method}")
-                        logging.info(f"Detected ROI with dimensions: ({x}, {y}, {w}, {h}) at scale {scale}, method {method}")
-                        return roi_img, (x, y, w, h)
-        
-        logging.info("No suitable ROI found, attempting fallback criteria.")
-        # Fallback with relaxed criteria
-        preprocessed = preprocess_image(img, method='clahe')
+        save_debug_image(img, "03_original")
+        preprocessed = preprocess_image(img)
+        brightness_map = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        block_size = max(9, min(31, int(img.shape[0] / 25) * 2 + 1))
         thresh = cv2.adaptiveThreshold(preprocessed, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                       cv2.THRESH_BINARY_INV, block_size, 5)
-        save_debug_image(thresh, "06_roi_fallback_threshold")
+                                       cv2.THRESH_BINARY_INV, block_size, 2)
+        save_debug_image(thresh, "04_roi_threshold")
         contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        valid_contours = [c for c in contours if 50 < cv2.contourArea(c) < (img.shape[0] * img.shape[1] * 0.95) and 
-                          0.2 <= cv2.boundingRect(c)[2]/cv2.boundingRect(c)[3] <= 25.0]
-        if valid_contours:
-            contour = max(valid_contours, key=cv2.contourArea)
-            x, y, w, h = cv2.boundingRect(contour)
-            padding = 150
-            x, y = max(0, x - padding), max(0, y - padding)
-            w, h = min(w + 2 * padding, img.shape[1] - x), min(h + 2 * padding, img.shape[0] - y)
-            roi_img = img[y:y+h, x:x+w]
-            save_debug_image(roi_img, "08_detected_roi_fallback")
-            logging.info(f"Detected fallback ROI with dimensions: ({x}, {y}, {w}, {h})")
-            return roi_img, (x, y, w, h)
         
-        logging.info("No suitable ROI found, returning original image.")
-        save_debug_image(img, "08_no_roi_original_fallback")
+        if contours:
+            img_area = img.shape[0] * img.shape[1]
+            valid_contours = []
+            for c in contours:
+                area = cv2.contourArea(c)
+                x, y, w, h = cv2.boundingRect(c)
+                roi_brightness = np.mean(brightness_map[y:y+h, x:x+w])
+                aspect_ratio = w / h
+                if (50 < area < (img_area * 0.95) and 
+                    0.2 <= aspect_ratio <= 30.0 and w > 30 and h > 10 and roi_brightness > 30):
+                    valid_contours.append((c, roi_brightness))
+                    logging.debug(f"Contour: Area={area}, Aspect={aspect_ratio:.2f}, Brightness={roi_brightness:.2f}")
+            
+            if valid_contours:
+                contour, _ = max(valid_contours, key=lambda x: x[1])
+                x, y, w, h = cv2.boundingRect(contour)
+                padding = 200
+                x, y = max(0, x - padding), max(0, y - padding)
+                w, h = min(w + 2 * padding, img.shape[1] - x), min(h + 2 * padding, img.shape[0] - y)
+                roi_img = img[y:y+h, x:x+w]
+                save_debug_image(roi_img, "05_detected_roi")
+                logging.info(f"Detected ROI: ({x}, {y}, {w}, {h})")
+                return roi_img, (x, y, w, h)
+        
+        logging.info("No ROI found, using full image.")
+        save_debug_image(img, "05_no_roi_fallback")
         return img, None
     except Exception as e:
         logging.error(f"ROI detection failed: {str(e)}")
-        save_debug_image(img, "08_roi_detection_error_fallback")
+        save_debug_image(img, "05_roi_error_fallback")
         return img, None
 
 def detect_segments(digit_img, brightness):
-    """Detect seven-segment patterns in a digit image."""
+    """Detect seven-segment digits."""
     h, w = digit_img.shape
-    if h < 8 or w < 6:
+    if h < 5 or w < 3:
         return None
 
     segments = {
@@ -180,7 +131,7 @@ def detect_segments(digit_img, brightness):
             continue
         pixel_count = np.sum(region == 255)
         total_pixels = region.size
-        segment_presence[name] = pixel_count / total_pixels > (0.15 if brightness < 80 else 0.35)
+        segment_presence[name] = pixel_count / total_pixels > (0.1 if brightness < 80 else 0.25)
 
     digit_patterns = {
         '0': ('top', 'bottom', 'left_top', 'left_bottom', 'right_top', 'right_bottom'),
@@ -200,46 +151,38 @@ def detect_segments(digit_img, brightness):
     for digit, pattern in digit_patterns.items():
         matches = sum(1 for segment in pattern if segment_presence.get(segment, False))
         non_matches_penalty = sum(1 for segment in segment_presence if segment not in pattern and segment_presence[segment])
-        score = matches - 0.15 * non_matches_penalty
-        if matches >= len(pattern) * 0.65:
+        score = matches - 0.1 * non_matches_penalty
+        if matches >= len(pattern) * 0.55:
             score += 1.0
         if score > max_score:
             max_score = score
             best_match = digit
     
-    logging.debug(f"Segment presence: {segment_presence}, Detected digit: {best_match}")
+    logging.debug(f"Segment presence: {segment_presence}, Digit: {best_match}")
     return best_match
 
 def custom_seven_segment_ocr(img, roi_bbox):
-    """Perform custom OCR for seven-segment displays."""
+    """Perform OCR for seven-segment displays."""
     try:
-        preprocessed = preprocess_image(img, method='clahe')
+        preprocessed = preprocess_image(img)
         brightness = estimate_brightness(img)
-        thresh_value = 60 if brightness < 80 else 0
-        _, thresh = cv2.threshold(preprocessed, thresh_value, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-        save_debug_image(thresh, "09_roi_thresh_for_digits")
-
-        # Morphological operations
-        kernel = np.ones((3, 3), np.uint8)
-        thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel, iterations=2)
-        save_debug_image(thresh, "10_morph_closed")
-
-        batch_size = max(4, min(16, int(img.shape[0] * img.shape[1] / 100000)))
+        _, thresh = cv2.threshold(preprocessed, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+        save_debug_image(thresh, "06_roi_thresh_digits")
         results = easyocr_reader.readtext(thresh, detail=1, paragraph=False, 
-                                          contrast_ths=0.1, adjust_contrast=1.3, 
-                                          text_threshold=0.3, mag_ratio=6.0, 
-                                          allowlist='0123456789.', batch_size=batch_size, y_ths=0.4)
+                                          contrast_ths=0.05, adjust_contrast=1.2, 
+                                          text_threshold=0.15, mag_ratio=4.0, 
+                                          allowlist='0123456789.', batch_size=2, y_ths=0.3)
         
-        logging.info(f"EasyOCR results (seven-segment): {results}")
+        logging.info(f"EasyOCR results: {results}")
         if not results:
-            logging.info("EasyOCR found no digits in seven-segment OCR.")
+            logging.info("No digits found.")
             return None
 
         digits_info = []
         for (bbox, text, conf) in results:
             (x1, y1), (x2, y2), (x3, y3), (x4, y4) = bbox
             h_bbox = max(y1, y2, y3, y4) - min(y1, y2, y3, y4)
-            if (text.isdigit() or text == '.') and h_bbox > 5:
+            if (text.isdigit() or text == '.') and h_bbox > 4:
                 x_min, x_max = int(min(x1, x4)), int(max(x2, x3))
                 y_min, y_max = int(min(y1, y2)), int(max(y3, y4))
                 digits_info.append((x_min, x_max, y_min, y_max, text, conf))
@@ -252,14 +195,14 @@ def custom_seven_segment_ocr(img, roi_bbox):
             if x_max <= x_min or y_max <= y_min:
                 continue
             digit_img_crop = thresh[y_min:y_max, x_min:x_max]
-            save_debug_image(digit_img_crop, f"11_digit_crop_{idx}_{easyocr_char}")
-            if easyocr_conf > 0.85 or easyocr_char == '.':
+            save_debug_image(digit_img_crop, f"07_digit_crop_{idx}_{easyocr_char}")
+            if easyocr_conf > 0.8 or easyocr_char == '.':
                 recognized_text += easyocr_char
             else:
                 digit_from_segments = detect_segments(digit_img_crop, brightness)
                 recognized_text += digit_from_segments if digit_from_segments else easyocr_char
         
-        logging.info(f"Before validation, recognized_text: {recognized_text}")
+        logging.info(f"Recognized text: {recognized_text}")
         text = re.sub(r"[^\d\.]", "", recognized_text)
         if text.count('.') > 1:
             text = text.replace('.', '', text.count('.') - 1)
@@ -268,122 +211,108 @@ def custom_seven_segment_ocr(img, roi_bbox):
             if text == '':
                 return None
             return text.lstrip('0') or '0'
-        logging.info(f"Custom OCR text '{recognized_text}' failed validation.")
+        logging.info(f"Text '{recognized_text}' failed validation.")
         return None
     except Exception as e:
-        logging.error(f"Custom seven-segment OCR failed: {str(e)}")
+        logging.error(f"Seven-segment OCR failed: {str(e)}")
         return None
 
 def extract_weight_from_image(pil_img):
-    """Extract weight from a PIL image of a digital scale display."""
+    """Extract weight from a digital scale image."""
     try:
         img = np.array(pil_img)
         img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
         save_debug_image(img, "00_input_image")
-
-        # Apply rotation correction
         img = correct_rotation(img)
-
         brightness = estimate_brightness(img)
-        conf_threshold = 0.65 if brightness > 150 else (0.45 if brightness > 80 else 0.25)
+        conf_threshold = 0.6 if brightness > 150 else (0.4 if brightness > 80 else 0.2)
 
         roi_img, roi_bbox = detect_roi(img)
         if roi_bbox:
-            roi_area = roi_bbox[2] * roi_bbox[3]
-            conf_threshold *= 1.1 if roi_area > (img.shape[0] * img.shape[1] * 0.5) else 1.0
+            conf_threshold *= 1.05 if (roi_bbox[2] * roi_bbox[3]) > (img.shape[0] * img.shape[1] * 0.5) else 1.0
 
         custom_result = custom_seven_segment_ocr(roi_img, roi_bbox)
         if custom_result and custom_result != '0':
             try:
                 weight = float(custom_result)
-                if 0.0001 <= weight <= 5000:
-                    logging.info(f"Custom OCR result: {custom_result}, Confidence: 95.0%")
-                    return custom_result, 95.0
-                else:
-                    logging.warning(f"Custom OCR result {custom_result} outside typical weight range.")
+                if 0.00001 <= weight <= 10000:
+                    logging.info(f"Custom OCR: {custom_result}, Confidence: 90.0%")
+                    return custom_result, 90.0
+                logging.warning(f"Custom OCR {custom_result} out of range.")
             except ValueError:
-                logging.warning(f"Custom OCR result '{custom_result}' is not a valid number.")
+                logging.warning(f"Custom OCR '{custom_result}' invalid number.")
 
-        logging.info("Custom OCR failed or invalid, falling back to enhanced EasyOCR.")
-        preprocessed_roi = preprocess_image(roi_img, method='hist')
-        block_size = max(9, min(31, int(roi_img.shape[0] / 25) * 2 + 1))
+        logging.info("Custom OCR failed, using EasyOCR fallback.")
+        preprocessed_roi = preprocess_image(roi_img)
         final_roi = cv2.adaptiveThreshold(preprocessed_roi, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                          cv2.THRESH_BINARY_INV, block_size, 5)
-        save_debug_image(final_roi, "12_fallback_adaptive_thresh")
+                                          cv2.THRESH_BINARY_INV, max(9, min(31, int(roi_img.shape[0] / 25) * 2 + 1)), 2)
+        save_debug_image(final_roi, "08_fallback_thresh")
 
-        batch_size = max(4, min(16, int(roi_img.shape[0] * roi_img.shape[1] / 100000)))
-        ocr_passes = [
-            {'contrast_ths': 0.2, 'text_threshold': 0.3, 'mag_ratio': 6.0, 'y_ths': 0.4, 'label': 'first'},
-            {'contrast_ths': 0.1, 'text_threshold': 0.2, 'mag_ratio': 7.0, 'y_ths': 0.5, 'label': 'second'},
-            {'contrast_ths': 0.05, 'text_threshold': 0.1, 'mag_ratio': 8.0, 'y_ths': 0.6, 'label': 'third'}
-        ]
-        candidates = []
+        results = easyocr_reader.readtext(final_roi, detail=1, paragraph=False, 
+                                          contrast_ths=0.05, adjust_contrast=1.2, 
+                                          text_threshold=0.15, mag_ratio=4.0, 
+                                          allowlist='0123456789. kglb', batch_size=2, y_ths=0.3)
 
-        for ocr_pass in ocr_passes:
+        if not results:
+            logging.info("First EasyOCR pass failed, trying fallback.")
             results = easyocr_reader.readtext(final_roi, detail=1, paragraph=False, 
-                                              contrast_ths=ocr_pass['contrast_ths'], 
-                                              adjust_contrast=1.4, 
-                                              text_threshold=ocr_pass['text_threshold'], 
-                                              mag_ratio=ocr_pass['mag_ratio'], 
-                                              allowlist='0123456789. kglb', 
-                                              batch_size=batch_size, 
-                                              y_ths=ocr_pass['y_ths'])
-            logging.info(f"EasyOCR results ({ocr_pass['label']} pass): {results}")
-            save_debug_image(final_roi, f"12_fallback_adaptive_thresh_{ocr_pass['label']}_pass")
-            
-            unit = None
-            for (bbox, text, conf) in results:
-                if 'kg' in text.lower():
-                    unit = 'kg'
-                    continue
-                elif 'g' in text.lower():
-                    unit = 'g'
-                    continue
-                elif 'lb' in text.lower():
-                    unit = 'lb'
-                    continue
-                text = re.sub(r"[^\d\.]", "", text)
-                if text.count('.') > 1:
-                    text = text.replace('.', '', text.count('.') - 1)
-                text = text.strip('.')
-                if re.fullmatch(r"^\d*\.?\d*$", text):
-                    try:
-                        weight = float(text)
-                        if unit == 'g':
-                            weight /= 1000
-                        elif unit == 'lb':
-                            weight *= 0.453592
-                        range_score = 1.5 if 0.0001 <= weight <= 5000 else 0.6
-                        digit_count = len(text.replace('.', ''))
-                        digit_score = 1.4 if 1 <= digit_count <= 8 else 0.7
-                        score = conf * range_score * digit_score
-                        if roi_bbox:
-                            (x_roi, y_roi, w_roi, h_roi) = roi_bbox
-                            roi_area = w_roi * h_roi
-                            x_min, y_min = int(min(b[0] for b in bbox)), int(min(b[1] for b in bbox))
-                            x_max, y_max = int(max(b[0] for b in bbox)), int(max(b[1] for b in bbox))
-                            bbox_area = (x_max - x_min) * (y_max - y_min)
-                            if roi_area > 0 and bbox_area / roi_area < 0.02:
-                                score *= 0.4
-                        candidates.append((text, conf, score, unit))
-                        logging.info(f"Candidate EasyOCR weight: '{text}', Unit: {unit or 'none'}, Conf: {conf}, Score: {score}")
-                    except ValueError:
-                        logging.warning(f"Could not convert '{text}' to float during EasyOCR fallback.")
+                                              contrast_ths=0.02, adjust_contrast=1.5, 
+                                              text_threshold=0.1, mag_ratio=5.0, 
+                                              allowlist='0123456789. kglb', batch_size=2, y_ths=0.3)
+            save_debug_image(final_roi, "08_fallback_thresh_fallback")
 
-        # Fallback to full image if no candidates
-        if not candidates:
-            logging.info("No candidates from ROI, trying full image.")
-            preprocessed_full = preprocess_image(img, method='hist')
+        logging.info(f"EasyOCR results: {results}")
+        candidates = []
+        unit = None
+        for (bbox, text, conf) in results:
+            if 'kg' in text.lower():
+                unit = 'kg'
+                continue
+            elif 'g' in text.lower():
+                unit = 'g'
+                continue
+            elif 'lb' in text.lower():
+                unit = 'lb'
+                continue
+            text = re.sub(r"[^\d\.]", "", text)
+            if text.count('.') > 1:
+                text = text.replace('.', '', text.count('.') - 1)
+            text = text.strip('.')
+            if re.fullmatch(r"^\d*\.?\d*$", text):
+                try:
+                    weight = float(text)
+                    if unit == 'g':
+                        weight /= 1000
+                    elif unit == 'lb':
+                        weight *= 0.453592
+                    range_score = 1.5 if 0.00001 <= weight <= 10000 else 0.5
+                    digit_count = len(text.replace('.', ''))
+                    digit_score = 1.4 if 1 <= digit_count <= 8 else 0.6
+                    score = conf * range_score * digit_score
+                    if roi_bbox:
+                        x_roi, y_roi, w_roi, h_roi = roi_bbox
+                        roi_area = w_roi * h_roi
+                        x_min, y_min = int(min(b[0] for b in bbox)), int(min(b[1] for b in bbox))
+                        x_max, y_max = int(max(b[0] for b in bbox)), int(max(b[1] for b in bbox))
+                        bbox_area = (x_max - x_min) * (y_max - y_min)
+                        if roi_area > 0 and bbox_area / roi_area < 0.02:
+                            score *= 0.4
+                    candidates.append((text, conf, score, unit))
+                    logging.info(f"Candidate: '{text}', Unit: {unit or 'none'}, Conf: {conf}, Score: {score}")
+                except ValueError:
+                    logging.warning(f"Could not convert '{text}' to float.")
+
+        if not candidates and not roi_bbox:
+            logging.info("No candidates, trying full image.")
+            preprocessed_full = preprocess_image(img)
             final_full = cv2.adaptiveThreshold(preprocessed_full, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                               cv2.THRESH_BINARY_INV, block_size, 5)
-            save_debug_image(final_full, "12_fallback_full_image")
+                                               cv2.THRESH_BINARY_INV, max(9, min(31, int(img.shape[0] / 25) * 2 + 1)), 2)
+            save_debug_image(final_full, "08_fallback_full")
             results = easyocr_reader.readtext(final_full, detail=1, paragraph=False, 
-                                              contrast_ths=0.1, adjust_contrast=1.5, 
-                                              text_threshold=0.2, mag_ratio=7.0, 
-                                              allowlist='0123456789. kglb', batch_size=batch_size, y_ths=0.5)
-            logging.info(f"EasyOCR results (full image): {results}")
-            
-            unit = None
+                                              contrast_ths=0.05, adjust_contrast=1.5, 
+                                              text_threshold=0.15, mag_ratio=4.0, 
+                                              allowlist='0123456789. kglb', batch_size=2, y_ths=0.3)
+            logging.info(f"Full image EasyOCR: {results}")
             for (bbox, text, conf) in results:
                 if 'kg' in text.lower():
                     unit = 'kg'
@@ -405,23 +334,20 @@ def extract_weight_from_image(pil_img):
                             weight /= 1000
                         elif unit == 'lb':
                             weight *= 0.453592
-                        range_score = 1.2 if 0.0001 <= weight <= 5000 else 0.5
+                        range_score = 1.2 if 0.00001 <= weight <= 10000 else 0.4
                         digit_count = len(text.replace('.', ''))
-                        digit_score = 1.2 if 1 <= digit_count <= 8 else 0.6
-                        score = conf * range_score * digit_score * 0.8  # Penalty for full image
+                        digit_score = 1.2 if 1 <= digit_count <= 8 else 0.5
+                        score = conf * range_score * digit_score * 0.7
                         candidates.append((text, conf, score, unit))
-                        logging.info(f"Candidate EasyOCR weight (full image): '{text}', Unit: {unit or 'none'}, Conf: {conf}, Score: {score}")
+                        logging.info(f"Full image candidate: '{text}', Unit: {unit or 'none'}, Conf: {conf}, Score: {score}")
                     except ValueError:
-                        logging.warning(f"Could not convert '{text}' to float during full image fallback.")
+                        logging.warning(f"Could not convert '{text}' to float (full image).")
 
         if not candidates:
-            logging.info("No valid weight detected after all attempts.")
+            logging.info("No valid weight detected.")
             return "Not detected", 0.0
 
-        # Select best candidate
         best_weight, best_conf, best_score, best_unit = max(candidates, key=lambda x: x[2])
-        
-        # Format the weight
         if "." in best_weight:
             int_part, dec_part = best_weight.split(".")
             int_part = int_part.lstrip("0") or "0"
@@ -432,16 +358,15 @@ def extract_weight_from_image(pil_img):
 
         try:
             final_weight = float(best_weight)
-            if final_weight < 0.0001 or final_weight > 5000:
-                best_conf *= 0.5
+            if final_weight < 0.00001 or final_weight > 10000:
+                best_conf *= 0.4
             elif final_weight == 0 and best_conf < 0.95:
-                best_conf *= 0.6  # Penalize zero weights
+                best_conf *= 0.5
         except ValueError:
             pass
 
-        logging.info(f"Final detected weight: {best_weight} kg, Confidence: {round(best_conf * 100, 2)}%, Unit: {best_unit or 'none'}")
+        logging.info(f"Final weight: {best_weight} kg, Confidence: {round(best_conf * 100, 2)}%, Unit: {best_unit or 'none'}")
         return best_weight, round(best_conf * 100, 2)
-
     except Exception as e:
-        logging.error(f"Weight extraction failed unexpectedly: {str(e)}")
+        logging.error(f"Weight extraction failed: {str(e)}")
         return "Not detected", 0.0