Fundamentos da Digitalização Digital de Documentos

Capturar documentos via smartphone é uma prática comum, porém, desafios como disterções geométricas, iluminação irregular e ruído visual prejudicam a precisão do Reconhecimento Óptico de Caracteres (OCR). Este guia técnico demonstra como integrar OpenCV e Tesseract para desenvolver uma ferramenta de digitalização capaz de processar imagens em tempo real e extrair texto de forma automatizada.

Arquitetura Técnica e Dependências

A solução utiliza um conjunto de bibliotecas robutsas para garantir performance e precisão:

• OpenCV: Manipulação de matrizes de imagem e transformações geométricas.
• PyTesseract: Interface para o motor OCR Tesseract.
• PyQt5: Framework para construção da interface gráfica (GUI).
• NumPy: Operações matemáticas em arrays multidimensionais.

# Instalação dos pacotes necessários
pip install opencv-python pytesseract numpy PyQt5

Fluxo de Processamento de Imagem

1. Pré-processamento Otimizado

Para que o motor de OCR funcione corretamente, a imagem deve ser limpa. Isso envolve converter para escala de cinza e aplicar técnicas de binarização.

import cv2
import numpy as np

def otimizar_captura(frame_original):
    # Conversão para tons de cinza
    cinza = cv2.cvtColor(frame_original, cv2.COLOR_BGR2GRAY)
    
    # Redução de ruído com desfoque mediano
    suavizada = cv2.medianBlur(cinza, 5)
    
    # Binarização adaptativa para lidar com sombras
    mascara = cv2.adaptiveThreshold(
        suavizada, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY, 11, 2
    )
    return mascara

2. Detecção de Contornos e Segmentação

O próximo passo é localizar as bordas do documento na cena. Utilizamos o algoritmo de Canny seguido pela busca de polígonos.

def identificar_documento(imagem_binaria):
    # Detecção de bordas
    bordas = cv2.Canny(imagem_binaria, 75, 200)
    
    # Localização de contornos
    formas, _ = cv2.findContours(bordas, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # Seleção do maior contorno (presumivelmente o papel)
    formas = sorted(formas, key=cv2.contourArea, reverse=True)
    
    for f in formas:
        perimetro = cv2.arcLength(f, True)
        aprox = cv2.approxPolyDP(f, 0.02 * perimetro, True)
        
        if len(aprox) == 4:
            return aprox
    return None

3. Correção de Perspectiva (Warp Transform)

Documentos raramente são fotografados em um ângulo perfeito de 90 graus. A transformação de perspectiva "planifica" a imagem.

def retificar_imagem(img, pontos):
    # Reordenar pontos: [superior-esq, superior-dir, inferior-dir, inferior-esq]
    pts = pontos.reshape(4, 2)
    soma = pts.sum(axis=1)
    dif = np.diff(pts, axis=1)
    
    origem = np.array([
        pts[np.argmin(soma)],
        pts[np.argmin(dif)],
        pts[np.argmax(soma)],
        pts[np.argmax(dif)]
    ], dtype="float32")
    
    # Calcular dimensões do novo documento
    largura = 500
    altura = 700
    
    destino = np.array([
        [0, 0],
        [largura - 1, 0],
        [largura - 1, altura - 1],
        [0, altura - 1]
    ], dtype="float32")
    
    matriz = cv2.getPerspectiveTransform(origem, destino)
    return cv2.warpPerspective(img, matriz, (largura, altura))

Integração com OCR

Após a retificação, a imagem está pronta para a extração de dados. O Tesseract suporta múltiplos idiomas e modos de segmentação de página (PSM).

import pytesseract

def extrair_texto_digital(imagem_processada):
    # Configuração específica para português e inglês
    config_ocr = '--oem 3 --psm 6'
    conteudo = pytesseract.image_to_string(
        imagem_processada, 
        lang='por+eng', 
        config=config_ocr
    )
    return conteudo

Interface Gráfica com PyQt5

Para uma aplicação prática, é necessário um loop de captura de vídeo e botões de interação.

from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QVBoxLayout, QWidget
from PyQt5.QtCore import QTimer
from PyQt5.QtGui import QImage, QPixmap

class AppScanner(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Scanner Vision Pro")
        self.camera = cv2.VideoCapture(0)
        
        self.label_video = QLabel()
        self.btn_scann = QPushButton("Digitalizar Documento")
        self.btn_scann.clicked.connect(self.processar_captura)
        
        layout = QVBoxLayout()
        layout.addWidget(self.label_video)
        layout.addWidget(self.btn_scann)
        
        container = QWidget()
        container.setLayout(layout)
        self.setCentralWidget(container)
        
        self.timer = QTimer()
        self.timer.timeout.connect(self.atualizar_frame)
        self.timer.start(30)

    def atualizar_frame(self):
        sucesso, frame = self.camera.read()
        if sucesso:
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            h, w, c = frame_rgb.shape
            img_qt = QImage(frame_rgb.data, w, h, w * c, QImage.Format_RGB888)
            self.label_video.setPixmap(QPixmap.fromImage(img_qt))

    def processar_captura(self):
        _, frame = self.camera.read()
        # Aqui integraria o fluxo: identificar_documento -> retificar_imagem -> extrair_texto_digital
        print("Documento processado com sucesso.")

Tratamento de Desafios Comuns

Correção de Iluminação Irregular

Em ambientes com sombras fortes, a equalização de histograma adaptativa (CLAHE) melhora significativamente a legibilidade.

def balancear_clonagem(img):
    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
    l, a, b = cv2.split(lab)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
    l_otimizado = clahe.apply(l)
    img_final = cv2.merge((l_otimizado, a, b))
    return cv2.cvtColor(img_final, cv2.COLOR_LAB2BGR)

Métricas de Performance e Otimização

A tabela abaixo apresenta o impacto das otimizações no tempo de processamento por quadro:

Para aumentar ainda mais a eficiência, recomenda-se o uso de processamento paralelo (Threading) para a função de OCR, permitindo que a interface gráfica permaneça responsiva enquanto o texto é extraído em segundo plano. Além disso, a integração de modelos de Deep Learning (como o EAST Text Detector) pode substituir a detecção de contornos tradicional em cenários de fundos complexos.