0Pricing
AI Agents · Aula

OCR para documentos digitalizados

Tesseract por meio do pytesseract, pré-processamento de imagens e melhoria da precisão.

OCR para documentos digitalizados é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Quando o OCR é necessário

Nem todos os documentos são PDFs nativamente digitais. Documentos digitalizados, fotografias de textos, anotações manuscritas e PDFs baseados em imagens exigem reconhecimento óptico de caracteres (OCR) para extrair texto.

O OCR converte imagens formadas por pixels de texto em caracteres legíveis por máquina. Duas das principais bibliotecas Python são: pytesseract (Google Tesseract) e EasyOCR (aprendizado profundo e suporte a vários idiomas).

Noções básicas de pytesseract

pytesseract é uma interface Python para o mecanismo de OCR Tesseract, do Google. Instale primeiro o Tesseract (no nível do OS) e depois execute pip install pytesseract Pillow.

import pytesseract
from PIL import Image

# Simple text extraction
image = Image.open('scanned_document.png')
text = pytesseract.image_to_string(image)
print(text)

# Specify language (default: English)
text_fr = pytesseract.image_to_string(
    Image.open('french_doc.png'),
    lang='fra'
)

# Get detailed output with bounding boxes
data = pytesseract.image_to_data(
    image,
    output_type=pytesseract.Output.DICT
)
for i, word in enumerate(data['text']):
    if word.strip():
        conf = data['conf'][i]
        print(f'Word: {word!r:20} Confidence: {conf}')

Pré-processamento de imagens: tons de cinza

A precisão do OCR depende muito da qualidade da imagem. A primeira etapa do pré-processamento é convertê-la para tons de cinza — a cor adiciona ruído sem ajudar no reconhecimento de caracteres.

Use Pillow ou OpenCV para o pré-processamento. Os tons de cinza reduzem o ruído e melhoram a detecção dos limites dos caracteres pelo Tesseract.

from PIL import Image, ImageOps
import numpy as np

def preprocess_grayscale(image_path):
    img = Image.open(image_path)

    # Convert to grayscale
    img = img.convert('L')  # 'L' = 8-bit grayscale

    # Optionally resize for better OCR (Tesseract works best at ~300 DPI)
    # Scale up small images
    width, height = img.size
    if width < 800:
        scale = 800 / width
        new_size = (int(width * scale), int(height * scale))
        img = img.resize(new_size, Image.LANCZOS)

    return img

img = preprocess_grayscale('scan.jpg')
text = pytesseract.image_to_string(img)
print(text[:300])

Pré-processamento de imagens: limiarização

A limiarização converte uma imagem em tons de cinza em preto e branco puros. Isso remove sombras cinzentas, iluminação irregular e ruído de fundo, fazendo o texto se destacar nitidamente para o OCR.

from PIL import Image, ImageFilter
import numpy as np

def apply_threshold(img):
    # Method 1: Simple fixed threshold
    img_array = np.array(img)
    threshold = 128
    binary = np.where(img_array > threshold, 255, 0).astype(np.uint8)
    return Image.fromarray(binary)

def adaptive_threshold(img):
    # Method 2: Otsu's method via OpenCV (better for uneven lighting)
    try:
        import cv2
        img_array = np.array(img)
        _, binary = cv2.threshold(
            img_array, 0, 255,
            cv2.THRESH_BINARY + cv2.THRESH_OTSU
        )
        return Image.fromarray(binary)
    except ImportError:
        return apply_threshold(img)

img = preprocess_grayscale('uneven_scan.png')
img_clean = adaptive_threshold(img)
text = pytesseract.image_to_string(img_clean)
print(text[:300])

Pré-processamento de imagens: correção da inclinação

Documentos digitalizados costumam estar ligeiramente girados. Até mesmo uma inclinação de 2 graus reduz significativamente a precisão do OCR. A correção da inclinação detecta e corrige o ângulo de rotação antes de passar a imagem ao mecanismo de OCR.

import numpy as np
from PIL import Image

def deskew(img):
    try:
        import cv2
        img_array = np.array(img)

        # Find rotation angle using Hough line transform
        edges = cv2.Canny(img_array, 50, 150, apertureSize=3)
        lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)

        if lines is None:
            return img  # no lines detected, return unchanged

        angles = []
        for line in lines:
            rho, theta = line[0]
            angle = np.degrees(theta) - 90
            if -45 < angle < 45:
                angles.append(angle)

        if not angles:
            return img

        median_angle = np.median(angles)
        if abs(median_angle) > 0.5:  # only deskew if significant tilt
            print(f'Deskewing by {median_angle:.2f} degrees')
            return img.rotate(-median_angle, expand=True, fillcolor=255)
        return img
    except ImportError:
        return img  # OpenCV not available — skip deskew

Opções de idioma do Tesseract

O Tesseract oferece suporte a mais de 100 idiomas. Baixe os pacotes de idioma com o gerenciador de pacotes do seu OS. Para documentos em vários idiomas, especifique vários idiomas usando um separador +.

import pytesseract
from PIL import Image

# List available languages
import subprocess
result = subprocess.run(['tesseract', '--list-langs'], capture_output=True, text=True)
print('Available languages:')
print(result.stdout)

# Single language
text_en = pytesseract.image_to_string(Image.open('doc.png'), lang='eng')

# Multiple languages (auto-detect best match)
text_multi = pytesseract.image_to_string(
    Image.open('doc.png'),
    lang='eng+fra+deu'  # English + French + German
)

# Tesseract config options for better accuracy
custom_config = r'--oem 3 --psm 6'  # OEM 3=LSTM, PSM 6=assume uniform block of text
text_tuned = pytesseract.image_to_string(
    Image.open('doc.png'),
    config=custom_config
)

EasyOCR: baseado em aprendizado profundo

EasyOCR usa modelos de aprendizado profundo e supera o Tesseract em imagens degradadas, textos curvos e escritas não latinas. Ele não exige instalação no nível do OS.

Instale-o com pip install easyocr. Na primeira execução, os pesos do modelo são baixados (~200 MB).

import easyocr

# Initialize reader (downloads model on first run)
reader = easyocr.Reader(
    ['en', 'tr'],  # list of languages
    gpu=False       # set True if CUDA available
)

# Read text from image
results = reader.readtext('scanned_page.png')

for (bbox, text, confidence) in results:
    print(f'Text: {text!r:30} Confidence: {confidence:.2f}')
    # bbox = [[x1,y1],[x2,y2],[x3,y3],[x4,y4]] (four corners)

# Get plain text only
text_only = ' '.join(result[1] for result in results)
print('Full text:', text_only[:300])

EasyOCR para documentos em vários idiomas

EasyOCR lida bem com documentos em vários idiomas — algo útil para contratos internacionais, artigos de pesquisa com legendas em vários idiomas ou documentos com termos técnicos em uma escrita diferente.

import easyocr

# For Arabic-English mixed document
reader_ar = easyocr.Reader(['ar', 'en'], gpu=False)
results = reader_ar.readtext('arabic_contract.png')

# For CJK languages
reader_cjk = easyocr.Reader(['ch_sim', 'en'], gpu=False)  # Simplified Chinese + English
results_cjk = reader_cjk.readtext('chinese_report.png')

# Filter by confidence threshold
HIGH_CONFIDENCE = 0.7
def filter_confident_results(results, threshold=HIGH_CONFIDENCE):
    return [
        (bbox, text, conf)
        for bbox, text, conf in results
        if conf >= threshold
    ]

Fluxo completo de pré-processamento

Encadeie todas as etapas de pré-processamento — tons de cinza, limiarização e correção da inclinação — em uma única função de fluxo de processamento. Execute o OCR na imagem limpa e retorne tanto o texto quanto as métricas de confiança.

import pytesseract
from PIL import Image

def ocr_pipeline(image_path, lang='eng', engine='tesseract'):
    print(f'Processing: {image_path}')

    # 1. Load
    img = Image.open(image_path)

    # 2. Preprocess
    img = img.convert('L')         # grayscale
    img = adaptive_threshold(img)  # binarize
    img = deskew(img)              # correct rotation

    # 3. OCR
    if engine == 'easyocr':
        reader = easyocr.Reader([lang], gpu=False)
        results = reader.readtext(image_path)
        text = ' '.join(r[1] for r in results if r[2] > 0.5)
    else:
        config = f'--oem 3 --psm 6 -l {lang}'
        text = pytesseract.image_to_string(img, config=config)

    # 4. Clean
    text = '\n'.join(
        line.strip() for line in text.splitlines()
        if line.strip()
    )
    return text

text = ocr_pipeline('invoice_scan.jpg')
print(text[:500])

Lidando com PDFs baseados em imagens

Alguns PDFs contêm páginas digitalizadas armazenadas como imagens dentro do contêiner PDF. Detecte esses 'PDFs de imagem' e aplique OCR página por página, usando PyMuPDF para extrair primeiro as imagens.

import fitz
from PIL import Image
import io
import pytesseract

def is_image_pdf(doc):
    # Check if first page has very little extractable text
    text = doc[0].get_text().strip()
    return len(text) < 50

def ocr_pdf(filepath):
    doc = fitz.open(filepath)
    if not is_image_pdf(doc):
        # Native text — no OCR needed
        return '\n'.join(doc[i].get_text() for i in range(len(doc)))

    print('Image PDF detected — running OCR')
    all_text = []

    for page_num in range(len(doc)):
        page = doc[page_num]
        # Render page as image at 300 DPI
        mat = fitz.Matrix(300/72, 300/72)  # scale to 300 DPI
        pix = page.get_pixmap(matrix=mat)
        img = Image.open(io.BytesIO(pix.tobytes('png')))
        text = pytesseract.image_to_string(img)
        all_text.append(f'--- Page {page_num+1} ---\n{text}')

    doc.close()
    return '\n'.join(all_text)

Filtragem por confiança e pós-processamento

A saída do OCR contém erros, especialmente em imagens degradadas. Faça o pós-processamento do texto filtrando palavras com baixa confiança, corrigindo erros comuns de OCR (0 vs O, 1 vs l) e normalizando os espaços em branco.

import re

COMMON_OCR_ERRORS = {
    r'\b0([a-z])\b': r'O\1',
    r'\bl([0-9])\b': r'1\1',
    r'\|': 'I',
    r'  +': ' ',
}

def post_process_ocr(text):
    for pattern, replacement in COMMON_OCR_ERRORS.items():
        text = re.sub(pattern, replacement, text)
    lines = [line.strip() for line in text.splitlines()]
    return '\n'.join(line for line in lines if line)

def high_confidence_ocr(words_with_conf, min_confidence=60):
    words = [w for w, conf in words_with_conf if w.strip() and conf >= min_confidence]
    return post_process_ocr(' '.join(words))

fake_ocr_output = [('0range', 90), ('|s', 40), ('l5', 85), ('good', 95)]
print(high_confidence_ocr(fake_ocr_output))

Verificação de conhecimento

Qual é a finalidade de aplicar um limiar (binarização) a uma imagem antes do OCR?

Recapitulação: OCR para documentos digitalizados

O OCR converte imagens digitalizadas em texto legível por máquina. pytesseract encapsula o Google Tesseract — rápido e consolidado, com mais de 100 pacotes de idioma. EasyOCR usa aprendizado profundo e lida melhor com imagens degradadas e textos em vários idiomas.

Sempre faça o pré-processamento: converta para tons de cinza, aplique a limiarização de Otsu para binarização e corrija a inclinação para corrigir a rotação. Para PDFs baseados em imagens, renderize as páginas como imagens de alta DPI com PyMuPDF e depois execute o OCR. Filtre os resultados por um limiar de confiança para excluir ruído.

Perguntas Frequentes

A aula “OCR para documentos digitalizados” é grátis?

Sim — o texto completo de “OCR para documentos digitalizados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “OCR para documentos digitalizados”?

Tesseract por meio do pytesseract, pré-processamento de imagens e melhoria da precisão. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Agents?

Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “OCR para documentos digitalizados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Agents?

Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Analisando PDFs com PyMuPDF e pdfplumber
  2. OCR para documentos digitalizados
  3. Agentes de perguntas e respostas em vários documentos
  4. Classificação e roteamento de documentos
← Voltar para AI Agents