Prefácio

Este livro constitui uma obra em permanente atualização nas áreas de Processamento Digital de Imagens (PDI) e Visão Computacional (VC), concebida como material didático interativo para cursos de graduação e pós-graduação em Computação, Engenharia e áreas afins.

Destaque

A obra fundamenta-se na metodologia descrita em Zampirolli et al. (2025) — extensão de Zampirolli et al. (2024), trabalho premiado na trilha Recursos e Ambientes Educacionais da EduComp 2024. O conteúdo integra a biblioteca morph.py, desenvolvida pelo autor.

Este não é um livro estático. Seu conteúdo evolui continuamente à medida que exemplos são aprimorados, novas seções são incorporadas e as abordagens pedagógicas são refinadas com base na experiência de uso e no retorno de estudantes e docentes. Dessa forma, a obra é tratada como um projeto em constante evolução, buscando acompanhar tanto os avanços tecnológicos quanto as melhores práticas de ensino em PDI e VC.

Contexto da primeira edição

O conteúdo desta edição foi elaborado entre maio e agosto de 2026, durante a primeira oferta da disciplina de Processamento Digital de Imagens baseada neste material didático. A disciplina foi ministrada em duas turmas de graduação — majoritariamente compostas por estudantes de Ciência da Computação, no período matutino — e em uma turma de pós-graduação em Ciência da Computação, todas na UFABC. Esta primeira edição representa o resultado dessa oferta inicial, consolidando o conteúdo desenvolvido, testado e continuamente aperfeiçoado ao longo do período letivo.

A metodologia de ensino adotada seguiu uma sequência estruturada em cada aula. Inicialmente, era exibido um vídeo curto, com duração média de 7 minutos, gerado no Gemini Notebook, alternando entre a apresentação da parte conceitual do capítulo e a resolução dos Exercícios de Programação (EPs). Neste segundo caso, quase todos os EPs eram resolvidos durante a própria aula. Em seguida, era apresentado um conjunto de aproximadamente 12 slides, também gerados no Gemini Notebook, tendo como fontes o PDF completo do livro e o arquivo morph.py. Esses slides eram produzidos a partir de um prompt específico para a geração do conteúdo teórico e prático de cada capítulo.

Após essa etapa inicial, restavam aproximadamente 100 minutos de aula para a exploração dos dois notebooks Colab do capítulo, um teórico e outro prático, com ênfase nos simuladores interativos e na execução dos blocos de código, permitindo aos estudantes modificar parâmetros e observar seus efeitos. Nas aulas realizadas em laboratório, os estudantes transferiam as respostas dos EPs desenvolvidas no Colab diretamente para as atividades VPL do Moodle, nas quais eram submetidas à avaliação automática. Esse processo de publicação e utilização dos EPs é apresentado ao final deste prefácio.

A avaliação contínua incluiu simulados quinzenais, aplicados com o SEB (Safe Exam Browser) no Moodle, contendo EPs semelhantes aos das listas de exercícios. Cada simulado concedia um bônus de 5% sobre a nota final. As duas provas da disciplina também utilizaram o SEB, mas foram compostas por questões parametrizadas geradas no MCTest, cuja descrição combina LaTeX e parâmetros no formato [[code:variavel]], definidos em trechos de Python delimitados por [[def: ... ]] na própria questão. Esse processo permitiu gerar 110 variações de prova, sorteadas individualmente entre os estudantes.

O Apêndice A detalha a criação dessas questões no MCTest e sua exportação para o Moodle; o Apêndice B descreve a configuração das atividades VPL, incluindo o processo de publicação dos EPs; o Apêndice C apresenta a configuração do SEB para os simulados e as provas; o Apêndice D descreve a geração dos vídeos e slides utilizados nas aulas com o Gemini Notebook; e o Apêndice E detalha o uso de Inteligência Artificial (IA) na geração de feedback socrático para atividades formativas e avaliativas, complementando a correção automática realizada pelo VPL.

Como este livro é produzido

O conteúdo deste livro é desenvolvido em Quarto e armazenado na pasta all do repositório github.com/fzampirolli/pdi-vc. A partir de um único código-fonte, o livro é automaticamente gerado e publicado em diferentes formatos, apresentados na Tabela 1.

Embora a edição em PDF registre o estado da obra ao término da primeira oferta da disciplina em 2026, o desenvolvimento do livro continua de forma permanente. A cada atualização do repositório GitHub, são geradas automaticamente novas versões das páginas HTML, do PDF e dos notebooks, disponibilizando imediatamente as melhorias aos leitores.

Tabela 1: Diferentes formatos de publicação gerados automaticamente a partir do mesmo código-fonte.

Formato	Descrição
HTML	Versão para web, com simuladores interativos e navegação entre capítulos: fzampirolli.github.io/pdi-vc/
PDF	Versão adequada para impressão ou leitura offline: livro.pt.py.pdf
Notebooks (`.ipynb`)	Compatíveis com Jupyter e Google Colab, permitindo executar, modificar e experimentar os exemplos de código e os Exercícios de Programação (EPs). Um filtro personalizado mantém referências cruzadas, numeração de figuras e tabelas, além de formatar automaticamente as citações conforme o padrão ABNT.

A obra é publicada em dez combinações — cada trilha de código (Python, 9 capítulos; C++, capítulos 1 a 5) em cinco idiomas (Português, Inglês, Francês, Espanhol e Italiano). Com o cache de tradução já povoado, uma regeneração completa (tradução, reexecução dos notebooks, renderização de HTML e PDF e publicação) leva cerca de 72 minutos, com paralelismo real de ~5 processos em média (pico de 8); a primeira geração de um idioma novo, com o cache vazio, é bem mais lenta — cerca de 80 minutos por combinação, como observado nas primeiras gerações de espanhol e italiano. A Tabela 2 resume cada combinação (já com o cache povoado): número de páginas do PDF e tempo de renderização.

Tabela 2: Páginas do PDF e tempo de renderização por combinação (paralelismo real médio de ~5 processos, pico de 8). A combinação-base em Python/Português apenas renderiza as saídas já registradas nos notebooks-fonte; as demais reexecutam todo o código.

Combinação	Trilha	Idioma	Páginas	Tempo de render.
`py.pt`	Python	Português (base)	654	~7 min
`py.en`	Python	Inglês	644	~31 min
`py.fr`	Python	Francês	666	~31 min
`py.es`	Python	Espanhol	666	~31 min
`py.it`	Python	Italiano	658	~31 min
`cpp.pt`	C++	Português	434	~26 min
`cpp.en`	C++	Inglês	426	~34 min
`cpp.fr`	C++	Francês	434	~38 min
`cpp.es`	C++	Espanhol	430	~37 min
`cpp.it`	C++	Italiano	428	~35 min

Estado de validação. Apenas a combinação py.pt (Python, Português) é a fonte curada: é nela que o autor escreve, revisa e valida todo o conteúdo. As outras nove combinações — as trilhas em C++ e as traduções para inglês, francês, espanhol e italiano — são geradas automaticamente, por tradução via modelo de linguagem e transpilação de código, e ainda carecem de revisão detalhada. A atenção maior recai sobre os textos embutidos em algumas figuras: onde a versão traduzida ainda não foi produzida, a imagem aparece com o texto em português (cada figura traduzida segue o mesmo sufixo de idioma dos demais arquivos gerados, por exemplo imagem_en.png).

As páginas HTML, o PDF e os notebooks disponibilizados no projeto refletem sempre o estado mais recente do desenvolvimento. Quando uma edição oficial é publicada, ela passa a ser identificada por uma tag no repositório GitHub, permitindo reproduzir exatamente o conteúdo correspondente àquela edição. Assim, o leitor pode acompanhar tanto a evolução contínua do projeto quanto recuperar qualquer edição oficial anteriormente publicada.

git clone https://github.com/fzampirolli/pdi-vc.git
cd pdi-vc
git checkout <tag-da-versao>

Cada capítulo disponibiliza dois botões Executar Colab (Figura 1), que direcionam para ambientes complementares:

Parte Teórica, localizada na abertura de cada capítulo, contendo os conceitos apresentados e exemplos de código executáveis;
Parte Prática, na seção Parte Prática com Exercícios de Programação (EPs), dedicada aos exercícios e aos seus simuladores interativos.

Figura 1: Botão clicável **Executar Colab**, disponível no início das partes **Teórica** e **Prática** de cada capítulo, permitindo a execução interativa dos exemplos e exercícios. Na versão PDF, existe um *link* HTML direto entre a imagem do simulador e a sua legenda.

A geração dos notebooks é totalmente automatizada pelo script gerar_notebooks_alunos.py, que adapta o conteúdo para ambientes interativos, permitindo sua execução sem a necessidade de instalação do Quarto.

Uso de ferramentas de Inteligência Artificial

A concepção, o projeto pedagógico, a estrutura conceitual e o conteúdo fundamental deste livro são de autoria exclusiva do autor.

No processo de editoração e apoio ao desenvolvimento, foram utilizadas, em suas versões gratuitas, ferramentas de Inteligência Artificial (IA), como ChatGPT, Claude, DeepSeek e Gemini, empregadas estritamente como recursos auxiliares. Seu uso restringiu-se ao apoio à revisão e ao aprimoramento do estilo textual, à otimização da sintaxe de códigos e à geração assistida de ilustrações conceituais e exemplos.

Todas as respostas e conteúdos sugeridos por essas ferramentas foram submetidos à análise crítica, verificação, validação técnica, adaptação e integração pelo autor, que assume a responsabilidade pelo texto, pelos códigos e pelos recursos pedagógicos apresentados. As ferramentas de IA não são consideradas autoras ou coautoras da obra, nem responsáveis pelas decisões intelectuais, técnicas ou pedagógicas que fundamentam seu conteúdo.

Destaca-se, ainda, que os simuladores e recursos interativos presentes no livro — disponibilizados nas versões HTML e Jupyter Notebook (IPYNB) — foram projetados e implementados como parte da abordagem pedagógica da obra, com o objetivo de proporcionar experimentação direta dos conceitos apresentados e favorecer a autonomia de aprendizagem do leitor.

Distinto do uso editorial descrito acima, o pipeline de geração multi-idioma (ver “Como este livro é produzido”) emprega um modelo de linguagem como componente de engenharia do sistema: a tradução automática do conteúdo entre português e outros idiomas, com cache incremental que evita retraduzir trechos inalterados. Essa etapa usa a API paga do DeepSeek (modelo deepseek-v4-flash); o livro completo já foi traduzido do português para o inglês, o francês, o espanhol e o italiano, e os Capítulos 1 a 5 contam ainda com uma trilha em C++ que compila e executa de verdade — a um custo acumulado da ordem de poucos dólares, graças ao cache incremental.

A biblioteca `morph.hpp`

A biblioteca morph.hpp (Zampirolli et al., 2025) acompanha toda a obra como uma ferramenta de apoio ao ensino. Seu objetivo não é substituir bibliotecas consolidadas, como OpenCV, nem competir com elas em desempenho ou abrangência. Em vez disso, procura tornar transparentes os algoritmos fundamentais de Processamento Digital de Imagens e Visão Computacional (PDI-VC), permitindo que o estudante compreenda sua implementação, modifique o código e desenvolva novas funcionalidades.

É o equivalente em C++ da morph.py: header-only (basta um #include "morph.hpp"), com os mesmos nomes de função no namespace mm:: — quem já conhece mm.dil(), mm.dil0() ou mm.gradm() em Python reconhece de imediato mm::dil(), mm::dil0() e mm::gradm() em C++. Divergência de nome entre as duas versões é considerada um defeito da biblioteca, não uma escolha de projeto.

Herança Técnica

A estrutura da morph.hpp (assim como a de sua contraparte morph.py) tem como base ferramentas de Morfologia Matemática desenvolvidas no Brasil, como MMachLib (Lotufo et al., 1997) e MMach (Barrera et al., 1998), além da mmorph, utilizada na obra de Dougherty; Lotufo (2003). Essas bibliotecas serviram de referência para o ensino da área durante décadas.

Essa filosofia pode ser observada, por exemplo, nos operadores morfológicos de dilatação:

mm::dil0: implementação didática da dilatação para elementos estruturantes planares, seguindo diretamente a definição clássica da Morfologia Matemática;
mm::dil1: implementação didática da dilatação para funções estruturantes (kernels não planares), seguindo rigorosamente sua formulação matemática;
mm::dil: por padrão, delega para mm::dil0() — a versão didática planar, numericamente equivalente a cv::dilate para elementos estruturantes desse tipo. A implementação otimizada, baseada em OpenCV (cv::dilate), só entra em ação se o programa for compilado com a flag -DMM_USE_OPENCV.

Uma diferença deliberada em relação à morph.py

Em Python, mm.dil() (sem sufixo) já é a implementação otimizada por padrão. Em C++, mm::dil() (mesmo nome, mesma assinatura) só se torna a versão otimizada se o OpenCV for explicitamente linkado na compilação; sem isso — que é justamente o caso padrão, inclusive no Moodle/VPL — mm::dil() se comporta como mm::dil0(). A escolha evita que a trilha C++ dependa do OpenCV apenas para compilar e rodar um exercício simples: g++ arquivo.cpp -o arquivo já é suficiente. Quem quiser a versão acelerada localmente compila com g++ -DMM_USE_OPENCV arquivo.cpp -o arquivo $(pkg-config --cflags --libs opencv4).

A biblioteca também oferece funções para leitura, exibição, conversão de cores, filtragem e morfologia matemática por meio de uma interface simples:

#include "morph.hpp"

int main() {
    mm::Image img = mm::gray(mm::read("lena.jpg"));  // leitura e conversão para níveis de cinza
    mm::Image grad = mm::gradm(img);                 // gradiente morfológico
    mm::show(grad, "saida.png");                     // exibição (grava em arquivo)
}

Ao contrário da versão Python, mm::show() exige um caminho de saída explícito: cada célula de código C++ do livro roda como um processo isolado (compilado e executado via %%writefile + !g++ ... no Colab), sem o contador global de figuras que só faz sentido dentro de um único processo Jupyter.

Além disso, todos os projetos do Gemini Notebook da trilha C++ incluem o arquivo morph.hpp, permitindo consultar e discutir diretamente a implementação dos algoritmos apresentados no livro. Dessa forma, o estudante pode utilizar o próprio Gemini Notebook como um assistente de estudos, fazendo perguntas como:

Explique como foi implementada a função mm::dil0 do morph.hpp, mostrando o código e comentando cada etapa de forma didática. Além disso, explique a diferença entre mm::dil0() e mm::dil() sem a flag -DMM_USE_OPENCV.

Implementações didáticas e implementações otimizadas

Em vários capítulos, um mesmo algoritmo é apresentado em duas versões. As funções com sufixo 0, 1, etc. (por exemplo, mm::dil0() e mm::dil1()) são implementações didáticas, desenvolvidas para facilitar o entendimento dos algoritmos e disponíveis independentemente da flag de compilação. Já as funções sem sufixo (como mm::dil()) usam a implementação otimizada baseada em OpenCV somente quando compiladas com -DMM_USE_OPENCV; caso contrário, comportam-se como a versão didática correspondente.

Nas atividades avaliadas pelo VPL do Moodle, a compilação segue o padrão sem -DMM_USE_OPENCV — não por limitação de memória (como ocorre com scikit-learn/scikit-image na trilha Python), mas para que nenhum EP em C++ dependa de o OpenCV estar instalado no ambiente de execução. Na prática, isso significa que, no VPL, mm::dil() e mm::dil0() produzem exatamente o mesmo resultado. Localmente — por exemplo, no VS Code ou no Google Colab —, o estudante pode optar por compilar com -DMM_USE_OPENCV para comparar a versão otimizada.

O código-fonte da biblioteca está disponível em:

https://github.com/fzampirolli/pdi-vc/tree/master/morph/cpp

Exercícios de Programação (EPs) e Validação Automática

Cada unidade do livro inclui Exercícios de Programação (EPs) práticos e de complexidade crescente, projetados para consolidar os conceitos apresentados ao longo do capítulo. Cada EP é acompanhado por um simulador interativo, disponível nas versões HTML e IPYNB, que permite ao estudante manipular parâmetros, visualizar o comportamento dos algoritmos e desenvolver uma compreensão intuitiva do problema antes de iniciar sua implementação. Dessa forma, o processo de aprendizagem combina experimentação, programação e validação automática.

A validação das soluções é feita localmente pela classe TestSuite (testsuite.py), que compara a saída do programa com os arquivos de casos de teste (.cases):

TestSuite("EP01_01.py").run()

O sistema suporta múltiplas linguagens (Python, Java, C++, C, JavaScript e R) e pode ser integrado diretamente ao Moodle. Para docentes interessados no passo a passo completo de publicação dos EPs como atividades VPL, consulte o Guia do Professor, ao final deste prefácio, e o Apêndice B.

Código aberto

O projeto é regido por princípios de código aberto. O repositório público reúne o texto, os códigos, as imagens e os scripts: github.com/fzampirolli/pdi-vc

Cada versão do livro é arquivada permanentemente no Zenodo com um DOI citable. Para citar este material em trabalhos acadêmicos:

ZAMPIROLLI, Francisco de Assis. PDI+VC — Processamento Digital de Imagens e Visão Computacional. UFABC, 2026. DOI: 10.5281/zenodo.20784605

Cabe registrar, por oportuno, que o conteúdo exposto nesta obra reflete o olhar crítico, a proposta pedagógica e a experiência docente de seu autor. Assim, as análises, abordagens e opiniões expressas ao longo deste livro representam tão somente o entendimento de seu idealizador, não constituindo nem refletindo um posicionamento oficial ou institucional da Universidade Federal do ABC (UFABC).

Antes de começar: Notebooks em Python

O conceito de Literate Programming (Programação Literária), proposto por Donald Knuth (Knuth, 1984), fundamenta a estrutura deste material. A lógica inverte o paradigma tradicional: o programa é escrito para a leitura humana, assemelhando-se a um ensaio, enquanto o código é extraído separadamente para execução computacional.

O conteúdo é estruturado em notebooks — documentos que intercalam células de texto (em Markdown) e células de código (em Python).

Execução: células de código são identificadas por [ ]. A execução pode ser realizada com Shift + Enter ou pelo botão ▶️ da interface.
Ambientes: os notebooks podem ser executados localmente, por meio do Jupyter ou do Visual Studio Code (VS Code), bem como em ambientes de nuvem, como o Google Colab.

Nota sobre o formato

Em ambientes interativos, o código pode ser modificado e executado. Nas versões estáticas (HTML ou PDF), os blocos de código têm finalidade de leitura e referência, sem prejuízo à integridade das explicações.

Guia do Professor: Publicação de EPs no Moodle

Esta seção destina-se a docentes que desejam integrar os Exercícios de Programação (EPs) às atividades VPL (Virtual Programming Lab) do Moodle, complementando o Apêndice B.

Integração com o Moodle (VPL)

Os EPs dos notebooks podem ser convertidos em atividades VPL no Moodle. O script ep_tools.py (executado via make build) automatiza a exportação dos EPs do final de cada capítulo em duas etapas:

Extração (make eps): gera um HTML interativo independente por EP, com enunciado, exemplos e simulador, em gen/book/eps/<versao>/. Veja a lista completa em: https://fzampirolli.github.io/pdi-vc/eps/py.pt/index.html
Conversão (make moodle): transforma o HTML em um fragmento autocontido, sem dependência de CSS externo, pronto para ser colado no editor do Moodle, em gen/book/eps/<versao>_moodle/. Veja um exemplo em: https://fzampirolli.github.io/pdi-vc/eps/py.pt_moodle/EP01_01.html

Adicionalmente, todos os simuladores interativos desenvolvidos ao longo do livro podem ser acessados diretamente em https://fzampirolli.github.io/pdi-vc/simuladores/py.pt/.

Outras trilhas e idiomas

Os links acima usam py.pt como exemplo. Para acessar EPs ou simuladores de outra combinação linguagem/idioma, basta trocar esse trecho na URL — por exemplo, cpp.it para a trilha C++ em italiano: https://fzampirolli.github.io/pdi-vc/eps/cpp.it/index.html. A estrutura é a mesma para todas as combinações disponíveis, em /eps/<versao>/, /eps/<versao>_moodle/ e /simuladores/<versao>/.

Ao publicar com make publish, essas duas versões de cada EP ficam disponíveis nos links indicados. O professor pode combinar as duas estratégias: colar a versão Moodle no editor VPL (com simulador funcional) e incluir no enunciado um link para a versão completa, onde as fórmulas são renderizadas corretamente pelo MathJax.

Revisão obrigatória antes de publicar no Moodle

Embora automatizada, a conversão exige revisão do professor em razão das limitações do editor TinyMCE/HTML Purifier do Moodle:

Fórmulas matemáticas — O TinyMCE descarta barras invertidas (\), corrompendo equações LaTeX. Por isso, a versão Moodle converte fórmulas simples para HTML puro (entidades como ≥, ×). Fórmulas complexas (\begin{cases}, matrizes, integrais) podem sair incompletas — revise e, se necessário, reescreva-as em texto ou indique a versão completa via link.
Figuras externas — Imagens complementares devem ser inseridas manualmente na atividade VPL.
Simuladores — Funcionam perfeitamente desde que utilizem JavaScript padrão com estilos inline e manipulação direta do DOM (getElementById). Atenção: se incluir fórmulas em LaTeX que contenham o caractere \ no Moodle, os simuladores podem parar de funcionar.

Como Publicar no Moodle

Acesse a versão Moodle do EP desejado:

https://fzampirolli.github.io/pdi-vc/eps/py.pt_moodle/EPXX_YY.html

Copie o código-fonte completo da página (Ctrl+U → Ctrl+A → Ctrl+C).
No Moodle, crie a atividade VPL, acesse o editor HTML, cole o conteúdo (Ctrl+V) e salve.
Importe os arquivos .cases da pasta all/capXX/casos/ nas configurações de testes do VPL.

Reaproveitamento dos Casos de Teste

Os arquivos .cases são compatíveis com o VPL, permitindo usar o mesmo conjunto de testes tanto no desenvolvimento local quanto na correção automatizada no Moodle.