Upload app.py

app.py

@@ -25,75 +25,173 @@ def order_points(pts):
     """
     rect = np.zeros((4, 2), dtype="float32")
     s = pts.sum(axis=1)
-    rect[0] = pts[np.argmin(s)]
-    rect[2] = pts[np.argmax(s)]
+    rect[0] = pts[np.argmin(s)]  # верх-лево
+    rect[2] = pts[np.argmax(s)]  # низ-право
     diff = np.diff(pts, axis=1)
-    rect[1] = pts[np.argmin(diff)]
-    rect[3] = pts[np.argmax(diff)]
+    rect[1] = pts[np.argmin(diff)]  # верх-право
+    rect[3] = pts[np.argmax(diff)]  # низ-лево
     return rect
 
-def correct_perspective(image):
+def find_text_region_contour(image):
     """
-    Находит текстовый блок и исправляет искажение перспективы.
+    Находит контур текстовой области более надежным способом.
     """
-    logging.info("Запуск коррекции перспективы...")
-    # Создаем копию, чтобы не изменять оригинал
-    img_for_transform = image.copy()
+    # Создаем несколько версий для поиска контуров
+    
+    # Метод 1: Морфологические операции для объединения символов
+    kernel_horizontal = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 1))
+    kernel_vertical = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 10))
+    
+    # Расширяем по горизонтали чтобы соединить буквы
+    dilated_h = cv2.dilate(image, kernel_horizontal, iterations=2)
+    # Небольшое расширение по вертикали
+    dilated = cv2.dilate(dilated_h, kernel_vertical, iterations=1)
     
-    # Инвертируем изображение для поиска контуров (белый текст на черном фоне)
-    inverted = cv2.bitwise_not(img_for_transform)
+    # Закрываем промежутки
+    kernel_close = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 8))
+    closed = cv2.morphologyEx(dilated, cv2.MORPH_CLOSE, kernel_close, iterations=1)
     
-    # Находим контуры. RETR_EXTERNAL находит только внешние контуры.
-    contours, _ = cv2.findContours(inverted, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    return closed
 
+def correct_perspective_improved(image):
+    """
+    Улучшенная коррекция перспективы с более надежным поиском текстовой области.
+    """
+    logging.info("Запуск улучшенной коррекции перспективы...")
+    
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image.copy()
+    
+    # Бинаризация если еще не сделана
+    if len(np.unique(gray)) > 2:
+        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+    else:
+        binary = gray.copy()
+    
+    # Инвертируем если нужно (текст должен быть белым)
+    if np.sum(binary == 255) < np.sum(binary == 0):
+        binary = cv2.bitwise_not(binary)
+    
+    # Находим область текста
+    text_region = find_text_region_contour(binary)
+    
+    # Находим контуры объединенной текстовой области
+    contours, _ = cv2.findContours(text_region, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
     if not contours:
-        logging.warning("Контуры не найдены. Пропуск коррекции перспективы.")
+        logging.warning("Контуры текстовой области не найдены.")
         return image
-
-    # Находим самый большой контур по площади
-    largest_contour = max(contours, key=cv2.contourArea)
     
-    # Находим минимальный ограничивающий прямоугольник (может быть повернут)
-    rect = cv2.minAreaRect(largest_contour)
-    box = cv2.boxPoints(rect)
+    # Берем самый большой контур
+    largest_contour = max(contours, key=cv2.contourArea)
     
-    # Проверка на адекватность: если найденный бокс слишком мал, это шум
-    if cv2.contourArea(box) < 500: # Пороговое значение, можно подбирать
-        logging.warning("Найденный контур слишком мал. Пропуск коррекции.")
+    # Проверяем минимальную площадь
+    if cv2.contourArea(largest_contour) < 1000:
+        logging.warning("Найденная текстовая область слишком мала.")
         return image
-
-    # Упорядочиваем 4 угла
-    ordered_box = order_points(box)
-    (tl, tr, br, bl) = ordered_box
-
-    # Вычисляем ширину и высоту целевого прямоугольника
-    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
-    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
-    maxWidth = max(int(widthA), int(widthB))
-
-    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
-    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
-    maxHeight = max(int(heightA), int(heightB))
     
-    # Проверка на адекватность соотношения сторон
-    if maxHeight == 0 or maxWidth / maxHeight < 1.5:
-        logging.warning(f"Неадекватное соотношение сторон ({maxWidth}/{maxHeight}). Пропуск коррекции.")
+    # Аппроксимируем контур до прямоугольника
+    epsilon = 0.02 * cv2.arcLength(largest_contour, True)
+    approx = cv2.approxPolyDP(largest_contour, epsilon, True)
+    
+    # Если не получили 4 точки, используем минимальный ограничивающий прямоугольник
+    if len(approx) != 4:
+        rect = cv2.minAreaRect(largest_contour)
+        box = cv2.boxPoints(rect)
+        approx = np.int0(box)
+    
+    # Преобразуем к нужному формату
+    if approx.shape[1] == 1:
+        approx = approx.squeeze(1)
+    
+    # Упорядочиваем точки
+    ordered_points = order_points(approx.astype("float32"))
+    
+    # Вычисляем размеры выходного изображения
+    (tl, tr, br, bl) = ordered_points
+    
+    # Ширина: максимум из верхней и нижней стороны
+    width_top = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
+    width_bottom = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
+    max_width = max(int(width_top), int(width_bottom))
+    
+    # Высота: максимум из левой и правой стороны
+    height_left = np.sqrt(((bl[0] - tl[0]) ** 2) + ((bl[1] - tl[1]) ** 2))
+    height_right = np.sqrt(((br[0] - tr[0]) ** 2) + ((br[1] - tr[1]) ** 2))
+    max_height = max(int(height_left), int(height_right))
+    
+    # Проверяем адекватность размеров
+    if max_width < 50 or max_height < 20:
+        logging.warning(f"Неадекватные размеры области: {max_width}x{max_height}")
         return image
+    
+    # Добавляем небольшие отступы для лучшего распознавания
+    padding = 10
+    max_width += padding * 2
+    max_height += padding * 2
+    
+    # Целевые точки (прямоугольник)
+    dst_points = np.array([
+        [padding, padding],                              # верх-лево
+        [max_width - padding, padding],                  # верх-право
+        [max_width - padding, max_height - padding],     # низ-право
+        [padding, max_height - padding]                  # низ-лево
+    ], dtype="float32")
+    
+    # Вычисляем матрицу трансформации и применяем
+    transform_matrix = cv2.getPerspectiveTransform(ordered_points, dst_points)
+    corrected = cv2.warpPerspective(
+        image, 
+        transform_matrix, 
+        (max_width, max_height),
+        flags=cv2.INTER_LINEAR,
+        borderMode=cv2.BORDER_CONSTANT,
+        borderValue=(255, 255, 255)
+    )
+    
+    logging.info(f"Коррекция перспективы применена. Размер: {max_width}x{max_height}")
+    return corrected
 
-    # Задаем точки назначения (идеальный прямоугольник)
-    dst = np.array([
-        [0, 0],
-        [maxWidth - 1, 0],
-        [maxWidth - 1, maxHeight - 1],
-        [0, maxHeight - 1]], dtype="float32")
-
-    # Вычисляем матрицу преобразования перспективы и применяем ее
-    M = cv2.getPerspectiveTransform(ordered_box, dst)
-    warped = cv2.warpPerspective(img_for_transform, M, (maxWidth, maxHeight), flags=cv2.INTER_LINEAR, borderValue=(255,255,255))
+def enhance_for_ocr(image):
+    """
+    Дополнительная обработка для улучшения OCR.
+    """
+    # Преобразуем в градации серого если нужно
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image.copy()
+    
+    # Увеличиваем контраст
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+    enhanced = clahe.apply(gray)
+    
+    # Бинаризация с адаптивным порогом
+    binary = cv2.adaptiveThreshold(
+        enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+        cv2.THRESH_BINARY, 11, 2
+    )
     
-    logging.info("Коррекция перспективы успешно применена.")
-    return warped
+    # Морфологическая очистка
+    kernel = np.ones((2,2), np.uint8)
+    cleaned = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=1)
+    cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_OPEN, kernel, iterations=1)
+    
+    return cleaned
 
+def correct_perspective(image):
+    """
+    Основная функция коррекции перспективы.
+    """
+    # Применяем улучшенную коррекцию перспективы
+    corrected = correct_perspective_improved(image)
+    
+    # Дополнительная обработка для OCR
+    enhanced = enhance_for_ocr(corrected)
+    
+    return enhanced
 
 def fetch_and_solve_captcha():
     try:
@@ -109,35 +207,36 @@ def fetch_and_solve_captcha():
         nparr = np.frombuffer(image_bytes, np.uint8)
         original_image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
-        scale_factor = 2
+        # Увеличиваем масштаб для лучшего качества
+        scale_factor = 3  # Увеличили с 2 до 3
         width = int(original_image.shape[1] * scale_factor)
         height = int(original_image.shape[0] * scale_factor)
         upscaled_image = cv2.resize(original_image, (width, height), interpolation=cv2.INTER_CUBIC)
 
+        # Выделение синего текста
         hsv = cv2.cvtColor(upscaled_image, cv2.COLOR_BGR2HSV)
         lower_blue = np.array([90, 50, 50])
         upper_blue = np.array([130, 255, 255])
         mask = cv2.inRange(hsv, lower_blue, upper_blue)
         
+        # Очистка маски
         kernel = np.ones((2, 2), np.uint8)
-        cleaned_mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=2)
-        
-        inverted_for_processing = cv2.bitwise_not(cleaned_mask)
-        
-        # ПРИМЕНЯЕМ НОВЫЙ АЛГОРИТМ КОРРЕКЦИИ
-        corrected_image = correct_perspective(inverted_for_processing)
+        cleaned_mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
         
-        processed_image = corrected_image
+        # ПРИМЕНЯЕМ УЛУЧШЕННУЮ КОРРЕКЦИЮ ПЕРСПЕКТИВЫ
+        corrected_image = correct_perspective(cleaned_mask)
         
-        tesseract_config = r'--oem 3 --psm 7 -c tessedit_char_whitelist=0123456789'
-        text = pytesseract.image_to_string(processed_image, config=tesseract_config)
+        # Настройки для Tesseract - более точные для цифр
+        tesseract_config = r'--oem 3 --psm 8 -c tessedit_char_whitelist=0123456789'
+        text = pytesseract.image_to_string(corrected_image, config=tesseract_config)
         recognized_text = re.sub(r'\s+', '', text).strip() or "Не распознано"
         logging.info(f"Распознано: {recognized_text}")
 
+        # Кодируем изображения для отображения
         _, buffer_orig = cv2.imencode('.png', original_image)
         original_b64 = base64.b64encode(buffer_orig).decode('utf-8')
         
-        _, buffer_proc = cv2.imencode('.png', processed_image)
+        _, buffer_proc = cv2.imencode('.png', corrected_image)
         processed_b64 = base64.b64encode(buffer_proc).decode('utf-8')
 
         return {
@@ -170,5 +269,3 @@ if __name__ == '__main__':
         solved_captchas.append(initial_captcha)
     
     app.run(host='0.0.0.0', port=7860, debug=False)
-
-