Latin and Cyrillic alphabet recognition in the same text

[bifshteksex]

Hi! I want to start by saying that I am very impressed with the quality of Latin recognition.
But if attach pictures on which need to recognize the Latin and Cyrillic letters at the same time, then some kind of bullshit happens.
I was looking for pre-trained models in Latin and Cyrillic, but I couldn't find anything((
Tell me, please, maybe there is a pre-trained model somewhere?

I'll attach my main.py:

import base64
import numpy as np
import cv2
from scipy.ndimage import rotate
import uuid
import os
import logging
from fastapi import FastAPI, HTTPException, UploadFile, File, Body
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import List, Tuple, Any, Optional, Dict
import uvicorn
from PIL import Image
import io

# --- OCR Engine Imports ---
from doctr.io import DocumentFile
from doctr.models import ocr_predictor

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("main")

app = FastAPI()

# --- CORS Configuration ---
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# --- OCR Engine Initialization ---
doctr_predictor = None

@app.on_event("startup")
async def startup_event():
    global doctr_predictor
    try:
        logger.info("Initializing docTR OCR...")
        
        # Initialize the standard OCR predictor
        doctr_predictor = ocr_predictor(
            pretrained=True,
            assume_straight_pages=True,
            preserve_aspect_ratio=True,
            symmetric_pad=True,
        )
        
        logger.info("docTR OCR initialized successfully.")
    except Exception as e:
        logger.error(f"Failed to initialize docTR OCR: {e}", exc_info=True)
        doctr_predictor = None

# --- Pydantic Models ---
class OCRRequest(BaseModel):
    image_data: str  # base64 encoded image string
    engine: Optional[str] = None
    languages: Optional[list] = None
    preprocess: Optional[bool] = None
    # Позволяет игнорировать лишние поля
    class Config:
        extra = "allow"

class OCRResponse(BaseModel):
    recognized_text: str
    confidence: float
    processing_time: float
    engine_used: str = "doctr"
    detailed_results: Optional[List[dict]] = None

# --- Helper Functions ---
def preprocess_image(image_data: str):
    try:
        header, encoded = image_data.split(",", 1)
        decoded_image = base64.b64decode(encoded)
        image_array = np.frombuffer(decoded_image, np.uint8)
        image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
        if image is None:
            raise ValueError("Could not decode image.")
        return image
    except Exception as e:
        logger.error(f"Error in preprocess_image: {e}")
        return None

def convert_doctr_results_to_json_serializable(result) -> List[dict]:
    processed_result = []
    if not result or not result.pages:
        return processed_result

    for page_idx, page in enumerate(result.pages):
        for block_idx, block in enumerate(page.blocks):
            for line_idx, line in enumerate(block.lines):
                for word_idx, word in enumerate(line.words):
                    geometry = word.geometry
                    # Защита: если точек меньше 4 — дублируем последнюю
                    box = []
                    for i in range(4):
                        if i < len(geometry):
                            box.append([int(geometry[i][0]), int(geometry[i][1])])
                        else:
                            box.append([int(geometry[-1][0]), int(geometry[-1][1])])
                    
                    processed_result.append({
                        "page": page_idx,
                        "block": block_idx,
                        "line": line_idx,
                        "word": word_idx,
                        "box": box,
                        "text": word.value,
                        "confidence": float(word.confidence),
                    })
    return processed_result

def calculate_overall_confidence(results: List[dict]) -> float:
    """Calculate overall confidence from word confidences"""
    if not results:
        return 0.0
    confidences = [word['confidence'] for word in results]
    return sum(confidences) / len(confidences)

# --- API Endpoints ---
@app.get("/health")
def health_check():
    if doctr_predictor is None:
        return {"status": "unhealthy", "reason": "OCR engine failed to initialize"}
    return {"status": "healthy", "engine": "doctr"}

@app.post("/ocr", response_model=OCRResponse)
async def recognize_text_endpoint(request: OCRRequest = Body(...)):
    if doctr_predictor is None:
        raise HTTPException(status_code=503, detail="OCR service is not available")

    try:
        import time
        start_time = time.time()
        
        # Preprocess the base64 image
        image = preprocess_image(request.image_data)
        if image is None:
            raise HTTPException(status_code=400, detail="Invalid image data")

        # Сохраняем во временный файл для docTR
        temp_filename = f"/tmp/{uuid.uuid4()}.png"
        cv2.imwrite(temp_filename, image)

        logger.info(f"Processing image from temporary file: {temp_filename}")

        # Проверяем, что файл существует и не пустой
        if not os.path.exists(temp_filename) or os.path.getsize(temp_filename) == 0:
            raise HTTPException(status_code=400, detail="Failed to save image for OCR.")

        # Create DocumentFile from file path
        try:
            doc = DocumentFile.from_images([temp_filename])
        except Exception as e:
            os.remove(temp_filename)
            logger.error(f"docTR failed to load image: {e}")
            raise HTTPException(status_code=400, detail="docTR could not load the image. Possibly unsupported or corrupted file.")

        # Run OCR
        result = doctr_predictor(doc)

        # Clean up the temporary file
        os.remove(temp_filename)

        # Проверяем, что есть страницы и блоки
        if not result.pages or not result.pages[0].blocks:
            raise HTTPException(status_code=400, detail="No text detected on the image.")

        processing_time = time.time() - start_time
        
        # Convert results to serializable format
        detailed_results = convert_doctr_results_to_json_serializable(result)
        
        # Extract text and calculate confidence
        recognized_text = " ".join([word['text'] for word in detailed_results])
        overall_confidence = calculate_overall_confidence(detailed_results)
        
        logger.info(f"Successfully recognized text with confidence {overall_confidence:.2%}")
        
        return OCRResponse(
            recognized_text=recognized_text,
            confidence=overall_confidence,
            processing_time=processing_time,
            engine_used="doctr",
            detailed_results=detailed_results
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error during OCR processing: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")

@app.post("/ocr_file")
async def ocr_from_file(file: UploadFile = File(...)):
    """
    An alternative endpoint for direct file uploads, useful for testing.
    """
    if doctr_predictor is None:
        raise HTTPException(status_code=503, detail="OCR service is not available")
    
    if not file.content_type.startswith("image/"):
        raise HTTPException(status_code=400, detail="File must be an image")

    try:
        import time
        start_time = time.time()
        
        # Read file content and save to temp file
        contents = await file.read()
        temp_filename = f"/tmp/{uuid.uuid4()}.png"
        
        with open(temp_filename, 'wb') as f:
            f.write(contents)
        
        # Проверяем, что файл существует и не пустой
        if not os.path.exists(temp_filename) or os.path.getsize(temp_filename) == 0:
            raise HTTPException(status_code=400, detail="Failed to save image for OCR.")

        # Create DocumentFile from file path
        try:
            doc = DocumentFile.from_images([temp_filename])
        except Exception as e:
            os.remove(temp_filename)
            logger.error(f"docTR failed to load image: {e}")
            raise HTTPException(status_code=400, detail="docTR could not load the image. Possibly unsupported or corrupted file.")
        
        # Run OCR
        result = doctr_predictor(doc)
        
        # Clean up the temporary file
        os.remove(temp_filename)
        
        # Проверяем, что есть страницы и блоки
        if not result.pages or not result.pages[0].blocks:
            raise HTTPException(status_code=400, detail="No text detected on the image.")
        
        processing_time = time.time() - start_time
        
        # Convert results
        detailed_results = convert_doctr_results_to_json_serializable(result)
        recognized_text = " ".join([word['text'] for word in detailed_results])
        overall_confidence = calculate_overall_confidence(detailed_results)
        
        return {
            "text": recognized_text,
            "confidence": overall_confidence,
            "processing_time": processing_time,
            "engine_used": "doctr",
            "detailed_results": detailed_results
        }
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"File OCR error: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail=f"File processing failed: {str(e)}")

if __name__ == "__main__":
    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True) 

[felixdittrich92]

Hi @bifshteksex 👋,

We don't have a pre-trained model including Cyrillic atm.
It's planned to provide multilingual models but this will still take some time.
So the easiest way would be to fine-tune your own model.

Best regards,
Felix