Evitando Alucinações: Preparando Imagens para Visão Computacional

O Desafio da Resolução em Projetos de Visão

Nos projetos atuais da AITY, um dos maiores desafios técnicos enfrentados é o tratamento de screenshots para automação. Frequentemente, capturamos telas em resoluções nativas, como 1366 x 768, mas ao enviar essas imagens para modelos de Inteligência Artificial, ocorrem erros de interpretação ou "alucinações".

Existe um mito de que IAs como o Gemini só conseguem "ver" imagens quadradas. A realidade técnica evoluiu, mas o pré-processamento continua sendo o fator decisivo para o sucesso ou falha da automação.

O Perigo do "Squash" (Esmagamento)

Antigamente, modelos clássicos (como as primeiras CNNs) exigiam entradas fixas e quadradas. Ao tentar adaptar um screenshot retangular (16:9) para esse formato, engenheiros frequentemente recorriam ao Squash — forçar a imagem a caber num quadrado.

O resultado é desastroso para a IA: botões retangulares viram quadrados e círculos viram ovais. Essa distorção geométrica destrói os padrões visuais que o modelo aprendeu, impedindo o reconhecimento correto de ícones e textos.

A Solução Moderna: Letterboxing

Modelos modernos, que utilizam arquiteturas Vision Transformers (ViT), dividem a imagem em pequenos ladrilhos (patches) e são mais flexíveis. No entanto, para garantir precisão absoluta nas coordenadas de clique e leitura (OCR), a geometria deve ser preservada.

A solução de engenharia definitiva é o Letterboxing (ou Padding).

• O Conceito: Criamos um canvas quadrado (ex: 1366x1366) com fundo preto ou branco.
• A Execução: Colamos o screenshot original no centro desse canvas.
• O Resultado: A IA recebe a imagem quadrada que processa melhor, mas os pixels do seu sistema mantêm a proporção original intacta, mantendo o texto legível e os botões em seu formato real.

Implementação em Python

Abaixo, compartilho o snippet desenvolvido para o ecossistema AITY. Este script utiliza a biblioteca Pillow (PIL) para aplicar o padding automaticamente, prevenindo alucinações antes de enviar os dados para a API.

from PIL import Image

def prepare_screenshot_for_ai(image_path, output_path="input_quadrado.jpg"):
    """
    Transforma um screenshot retangular em uma imagem quadrada
    adicionando bordas (padding), sem distorcer o conteúdo.
    Isso evita alucinações de geometria em modelos de visão.
    """
    try:
        # 1. Carrega a imagem original
        original_img = Image.open(image_path)
        old_width, old_height = original_img.size
        
        # 2. Define o tamanho do novo quadrado baseado no lado maior
        # Ex: Se 1366x768, o novo tamanho será 1366x1366
        new_size = max(old_width, old_height)
        
        # 3. Cria um canvas quadrado (0, 0, 0) é preto.
        new_img = Image.new("RGB", (new_size, new_size), (0, 0, 0))
        
        # 4. Calcula a posição para centralizar a imagem original
        x_offset = (new_size - old_width) // 2
        y_offset = (new_size - old_height) // 2
        
        # 5. Cola a imagem original no centro (sem dar stretch/resize)
        new_img.paste(original_img, (x_offset, y_offset))
        
        # 6. Salva o resultado
        new_img.save(output_path)
        print(f"✅ Processo concluído: {output_path} ({new_size}x{new_size}).")
        return output_path

    except Exception as e:
        print(f"❌ Erro ao processar imagem: {e}")

if __name__ == "__main__":
    prepare_screenshot_for_ai("meu_screenshot_1366x768.png")