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.py`

A biblioteca morph.py (Zampirolli et al., 2025) acompanha toda a obra como uma ferramenta de apoio ao ensino. Seu objetivo não é substituir bibliotecas consolidadas, como OpenCV, scikit-image, scikit-learn, NumPy ou Matplotlib, 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.

Sempre que possível, a biblioteca oferece duas versões para um mesmo algoritmo: uma implementação didática, escrita passo a passo para refletir diretamente as definições matemáticas apresentadas no livro, e outra implementação otimizada, baseada em bibliotecas especializadas para aplicações práticas.

Herança Técnica

A estrutura da 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.dil: implementação otimizada, indicada para aplicações práticas;
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.

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:

from morph import mm

img = mm.gray(mm.read("lena.jpg"))  # leitura e conversão para níveis de cinza
grad = mm.gradm(img)                # gradiente morfológico
mm.show(grad)                       # exibição

Ao longo do livro, novos métodos são introduzidos na biblioteca para simplificar a realização dos Exercícios de Programação (EPs). Entre eles estão mm.readTrain() e mm.readTest(), que automatizam a leitura das bases de treinamento e teste utilizadas nos capítulos dedicados ao reconhecimento de padrões.

Além disso, todos os projetos do Gemini Notebook incluem o arquivo morph.py, 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 implementado o algoritmo mm.knn0 do morph.py, mostrando o código e comentando cada etapa de forma didática. Além disso, explique as diferenças entre mm.knn0() e mm.knn().

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.knn0(), mm.dil0() e mm.dil1()) são implementações didáticas, desenvolvidas para facilitar o entendimento dos algoritmos. Já as funções sem sufixo (como mm.knn() e mm.dil()) utilizam implementações otimizadas, frequentemente baseadas em bibliotecas especializadas, como OpenCV, scikit-image e scikit-learn, sendo mais adequadas para aplicações práticas.

Nas atividades avaliadas pelo VPL do Moodle, bibliotecas como scikit-learn e, em alguns casos, scikit-image, podem não ser utilizadas devido às limitações de memória do ambiente de execução. Por esse motivo, os Exercícios de Programação (EPs) empregam preferencialmente as implementações didáticas da morph.py, que produzem os mesmos resultados, embora com menor desempenho computacional. Essa restrição não existe quando os programas são executados localmente, por exemplo, no VS Code, Jupyter Notebook ou Google Colab.

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

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

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.