Capítulo 1: Introdução à Visão Computacional

Contents

Capítulo 1: Introdução à Visão Computacional#

cover

🟡⚫ Google Colab, Linux e Bibliotecas#

O Google Colab (Colaboratory) é um ambiente de nuvem baseado em Jupyter Notebooks que permite escrever e executar código Python diretamente no navegador. Para tarefas de visão computacional, ele se destaca por ser uma plataforma de “configuração zero”, eliminando a necessidade de instalar complexos drivers de GPU ou ambientes locais pesados.

Neste capítulo, exploraremos como utilizar essa plataforma para acelerar o desenvolvimento de projetos, desde a configuração básica até o uso de aceleradores de hardware.

colab_interface

Por que utilizar o Google Colab?#

Diferente de um ambiente local, o Colab oferece infraestrutura poderosa de forma gratuita, sendo um divisor de águas para estudantes e pesquisadores.

Principais Vantagens:

✅ Zero Configuração – Sem necessidade de instalar Python ou bibliotecas localmente para começar.
✅ Acesso Gratuito a GPUs (Unidades de Processamento Gráfico) – Essencial para processar grandes volumes de imagens e treinar redes neurais profundas.
✅ Integração com Ecossistema Google – Salve seus notebooks e datasets diretamente no Google Drive.
✅ Portabilidade – Acesse seus projetos de qualquer computador com acesso à internet.

Configurando o Hardware (GPU)#

Para tarefas de Visão Computacional, é altamente recomendável ativar a aceleração por hardware:

  1. Vá em Ambiente de execução > Alterar tipo de ambiente de execução.

  2. Em Acelerador de hardware, selecione T4 GPU (ou superior, se disponível).

Gerenciamento de Pacotes: Do pip ao uv#

Gerenciar bibliotecas é uma parte vital do fluxo de trabalho. Embora o pip seja o padrão histórico, ferramentas mais modernas como o uv estão redefinindo a velocidade e a confiabilidade nesse processo.

Visão Geral: Sistema Operacional, Python e Ambientes Virtuais#

Antes de explorar os gerenciadores de pacotes, é fundamental entender como o Python se relaciona com o sistema operacional e por que ambientes virtuais são essenciais para organizar seus projetos.

+-----------------------------------------------------------------------------+
|                         SISTEMA OPERACIONAL                                 |
|                      (Linux, Windows, macOS)                                |
+-----------------------------------------------------------------------------+
|                                                                             |
|   +---------------------------------------------------------------------+   |
|   |                    INSTALACAO DO PYTHON                             |   |
|   |                  (Python 3.10, 3.11, 3.12...)                       |   |
|   +---------------------------------------------------------------------+   |
|                                    |                                        |
|            +-----------------------+-----------------------+                |
|            |                       |                       |                |
|            v                       v                       v                |
|   +-----------------+     +-----------------+     +-----------------+       |
|   |   PROJETO A     |     |   PROJETO B     |     |   PROJETO C     |       |
|   | (Visao Comp.)   |     | (Web App)       |     | (Data Science)  |       |
|   +-----------------+     +-----------------+     +-----------------+       |
|   | .venv/          |     | .venv/          |     | .venv/          |       |
|   | +-- bin/        |     | +-- bin/        |     | +-- bin/        |       |
|   | +-- lib/        |     | +-- lib/        |     | +-- lib/        |       |
|   | +-- python3.11  |     | +-- python3.11  |     | +-- python3.12  |       |
|   +-----------------+     +-----------------+     +-----------------+       |
|   | PACOTES:        |     | PACOTES:        |     | PACOTES:        |       |
|   | - opencv 4.9    |     | - flask 3.0     |     | - pandas 2.2    |       |
|   | - numpy 1.26    |     | - sqlalchemy    |     | - scikit-learn  |       |
|   | - matplotlib    |     | - jinja2        |     | - seaborn       |       |
|   | - torch 2.2     |     | - requests      |     | - jupyter       |       |
|   +-----------------+     +-----------------+     +-----------------+       |
|            |                       |                       |                |
|            |    pip install        |    pip install        |   uv pip       |
|            |    uv pip install     |    uv pip install     |   install      |
|            v                       v                       v                |
|   +---------------------------------------------------------------------+   |
|   |                    PyPI (Python Package Index)                      |   |
|   |                   Repositorio central de pacotes                    |   |
|   |                        https://pypi.org                             |   |
|   +---------------------------------------------------------------------+   |
|                                                                             |
+-----------------------------------------------------------------------------+

Por que usar ambientes virtuais?

Problema sem Ambiente Virtual

Solucao com Ambiente Virtual

Conflitos de versoes entre projetos

Cada projeto tem suas proprias versoes de pacotes

Dificuldade em reproduzir o ambiente

requirements.txt documenta exatamente o que foi usado

Poluicao do Python global do sistema

Pacotes ficam isolados na pasta .venv do projeto

Quebra de projetos antigos ao atualizar

Cada projeto mantem suas dependencias intactas

Fluxo de trabalho recomendado:

Etapa

Comando

Descricao

1

mkdir meu_projeto && cd meu_projeto

Criar e entrar na pasta do projeto

2

uv venv

Criar ambiente virtual

3

source .venv/bin/activate

Ativar o ambiente

4

uv pip install opencv-python numpy

Instalar pacotes

5

python main.py

Desenvolver e executar

6

uv pip freeze > requirements.txt

Exportar dependencias

Analogia: Pense em cada ambiente virtual como um quarto separado para cada projeto. Cada quarto tem suas proprias ferramentas e decoracao, sem interferir nos outros. Quando voce “ativa” o ambiente, esta “entrando” naquele quarto especifico.

O Gerenciador de Pacotes pip#

O pip (Python Package Installer) é o gerenciador padrão do ecossistema Python. No ambiente do Google Colab, ele é a ferramenta primária para garantir a persistência das bibliotecas instaladas durante a sessão de execução. É recomendável utilizar o prefixo ! antes dos comandos para assegurar a execução via shell.

Principais Comandos do pip

Ação

Comando

Descrição

Listar

!pip list

Exibe todos os pacotes instalados e suas respectivas versões.

Versões Disponíveis

!pip index versions <pacote>

Lista todas as versões disponíveis de um pacote no PyPI.

Instalar

!pip install <pacote>

Baixa e instala a versão mais recente de uma biblioteca.

Instalar via Arquivo

!pip install -r requirements.txt

Instala todos os pacotes listados em um arquivo de dependências.

Versão Específica

!pip install <pacote>==<versão>

Instala uma versão exata para garantir compatibilidade.

Atualizar

!pip install --upgrade <pacote>

Atualiza um pacote já instalado para a última versão estável.

Informações

!pip show <pacote>

Mostra detalhes como autor, local de instalação e dependências.

Remover

!pip uninstall -y <pacote>

Remove uma biblioteca do ambiente atual.

Exportar

!pip freeze > requirements.txt

Gera um arquivo com todas as dependências do projeto.

O Gerenciador de Pacotes uv#

O uv é um gerenciador de pacotes e ambientes virtuais escrito em Rust, desenvolvido pela Astral (mesma equipe do Ruff). Ele foi projetado para ser um substituto moderno e extremamente rápido do pip, pip-tools e virtualenv.

Por que usar o uv?

Característica

Benefício

Velocidade

Até 10-100x mais rápido que o pip em instalações e resolução de dependências.

Ambiente Integrado

Cria e gerencia ambientes virtuais sem ferramentas adicionais.

Resolução Moderna

Algoritmo de resolução de dependências mais robusto, evitando conflitos.

Cache Inteligente

Reutiliza downloads anteriores, economizando tempo e banda.

Compatibilidade

Funciona com requirements.txt e pyproject.toml existentes.

Instalação do uv

# No Linux/macOS (via script oficial)
curl -LsSf https://astral.sh/uv/install.sh | sh

# No Windows (via PowerShell)
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

# Ou via pip (qualquer sistema)
pip install uv

Exemplo Prático: Criando um Projeto de Visão Computacional

Vamos criar um projeto chamado meu_projeto_cv com ambiente virtual isolado:

# 1. Criar a pasta do projeto e entrar nela
mkdir meu_projeto_cv
cd meu_projeto_cv

# 2. Criar um ambiente virtual com Python 3.11
uv venv --python 3.11

# 3. Ativar o ambiente virtual
source .venv/bin/activate      # Linux/macOS
# .venv\Scripts\activate       # Windows

# 4. Instalar as bibliotecas de visão computacional
uv pip install opencv-python numpy matplotlib scikit-image pillow

# 5. Verificar os pacotes instalados
uv pip list

# 6. Exportar as dependências para reprodutibilidade
uv pip freeze > requirements.txt

# 7. Desativar o ambiente quando terminar
deactivate

Principais Comandos do uv

Ação

Comando

Descrição

Criar Ambiente

uv venv

Cria um ambiente virtual .venv no diretório atual.

Criar com Python Específico

uv venv --python 3.11

Cria ambiente com uma versão específica do Python.

Instalar Pacote

uv pip install <pacote>

Instala um pacote no ambiente ativo.

Instalar via Arquivo

uv pip install -r requirements.txt

Instala dependências de um arquivo.

Listar Pacotes

uv pip list

Lista todos os pacotes instalados.

Remover Pacote

uv pip uninstall <pacote>

Remove um pacote do ambiente.

Exportar

uv pip freeze > requirements.txt

Gera arquivo de dependências.

Sincronizar

uv pip sync requirements.txt

Instala exatamente o que está no arquivo, removendo extras.

Recriando o Ambiente em Outra Máquina

Com o arquivo requirements.txt gerado, qualquer pessoa pode recriar o mesmo ambiente:

# Clonar/copiar o projeto e entrar na pasta
cd meu_projeto_cv

# Criar e ativar o ambiente
uv venv
source .venv/bin/activate

# Instalar todas as dependências
uv pip install -r requirements.txt

💡 Nota sobre o Google Colab: No ambiente do Colab, o uv pode ser usado para instalações rápidas com !uv pip install, mas a criação de ambientes virtuais isolados não persiste entre sessões. Para projetos locais, o fluxo completo com uv venv é altamente recomendado.

Comandos Essenciais para Gerenciamento#

Abaixo estão os comandos mais comuns para manter seu ambiente organizado:

# Listar todos os pacotes instalados no ambiente
!uv pip list

# Mostrar informações detalhadas sobre um pacote específico
!pip show numpy

# Remover um pacote e suas dependências
!uv pip uninstall opencv-python -y

# Gerar um arquivo requirements.txt para garantir a reprodutibilidade do projeto
!uv pip freeze > requirements.txt

# Reinstalar dependências a partir de um arquivo requirements.txt
!uv pip install -r requirements.txt

O que cada biblioteca faz?#

  • NumPy – Manipulação eficiente de arrays e matrizes, essencial para processamento numérico e imagens.

  • OpenCV – Biblioteca poderosa para processamento de imagens e vídeos, incluindo filtros, transformações e detecção de objetos.

  • Matplotlib – Ferramenta para visualização de gráficos e exibição de imagens processadas.

  • Scikit-Image – Conjunto avançado de algoritmos para análise e manipulação de imagens.

  • Pillow – Manipulação e conversão de imagens em diversos formatos.

💡 Dica: No Google Colab, muitas dessas bibliotecas já vêm pré-instaladas. Porém, rodar o comando acima garante que você tenha a versão mais atualizada para o seu projeto.

Estrutura de Diretórios do Linux#

Antes de explorarmos os comandos do terminal, é fundamental entender como o sistema de arquivos do Linux está organizado. Diferente do Windows, que usa letras de unidade (C:, D:), o Linux possui uma estrutura hierárquica única, onde tudo começa a partir de um diretório raiz /.

Veja abaixo uma representação simplificada dos principais diretórios:

/                          ← Raiz do sistema (tudo começa aqui)
├── home/                  ← Diretórios pessoais dos usuários
│   ├── joao/              ← Pasta do usuário "joao"
│   │   ├── Documentos/
│   │   ├── Downloads/
│   │   └── projetos/
│   └── maria/             ← Pasta do usuário "maria"
│
├── bin/                   ← Programas essenciais (ls, cp, mv, cat...)
├── usr/                   ← Programas e bibliotecas do usuário
│   ├── bin/               ← Programas adicionais
│   └── lib/               ← Bibliotecas compartilhadas
│
├── etc/                   ← Arquivos de configuração do sistema
├── var/                   ← Dados variáveis (logs, cache, banco de dados)
├── tmp/                   ← Arquivos temporários
├── root/                  ← Diretório pessoal do administrador (root)
└── dev/                   ← Dispositivos de hardware (HD, USB, GPU...)

Entendendo os principais diretórios:

Diretório

Descrição

/

Diretório raiz, ponto de partida de toda a estrutura

/home

Contém as pastas pessoais de cada usuário do sistema

/bin

Binários essenciais do sistema (comandos básicos como ls, cp)

/usr

Programas e bibliotecas instalados pelo usuário

/etc

Arquivos de configuração do sistema e aplicações

/var

Dados que mudam frequentemente (logs, cache)

/tmp

Arquivos temporários (apagados ao reiniciar)

/root

Pasta pessoal do superusuário (administrador)

/dev

Representação de dispositivos de hardware

Caminhos Absolutos vs Relativos:

  • Caminho absoluto: Começa sempre com / e indica a localização completa
    Exemplo: /home/joao/projetos/visao_computacional

  • Caminho relativo: Parte do diretório atual
    Exemplo: Se você está em /home/joao, pode acessar projetos/visao_computacional

Símbolos especiais de navegação:

Símbolo

Significado

.

Diretório atual

..

Diretório pai (um nível acima)

~

Diretório home do usuário atual

/

Diretório raiz

Exemplo prático no Google Colab:

No Google Colab, você trabalha principalmente no diretório /content, que funciona como seu espaço de trabalho:

/content/                  ← Seu diretório de trabalho no Colab
├── sample_data/           ← Dados de exemplo do Colab
├── drive/                 ← Google Drive montado (se conectado)
│   └── MyDrive/
└── meu_projeto/           ← Suas pastas e arquivos
    ├── dados/
    ├── modelos/
    └── resultados/

Compreender essa estrutura facilitará muito a navegação e organização dos seus projetos!

Comandos e Terminal Linux para IA#

O domínio do terminal Linux é uma habilidade essencial para quem trabalha com Inteligência Artificial e Visão Computacional. Seja no Google Colab (que roda sobre máquinas virtuais Linux), em servidores de treinamento ou em sua própria máquina, os comandos apresentados aqui serão utilizados diariamente.

No Google Colab, prefixe os comandos com ! para executá-los no shell do sistema.

Criação e Manipulação de Arquivos#

Comando

Descrição

Exemplo

echo

Exibe texto na tela ou escreve em arquivos

!echo "Olá, mundo!"

mkdir

Cria um diretório

!mkdir datasets

mkdir -p

Cria diretórios aninhados

!mkdir -p projeto/dados/treino

touch

Cria arquivo vazio ou atualiza data de modificação

!touch config.yaml

cp

Copia arquivos

!cp modelo.h5 backup_modelo.h5

cp -r

Copia diretórios recursivamente

!cp -r datasets/ datasets_backup/

mv

Move ou renomeia arquivos/diretórios

!mv modelo_v1.h5 modelos/

rm

Remove arquivos

!rm arquivo_temporario.txt

rm -r

Remove diretórios e conteúdo

!rm -r pasta_antiga/

rm -rf

Remove forçadamente (use com cuidado!)

!rm -rf __pycache__/

tree

Exibe estrutura de diretórios em árvore (instalar: apt install tree)

!tree -L 2

Usando echo para criar arquivos:

# Escrever texto em um novo arquivo (sobrescreve se existir)
!echo "primeira linha" > arquivo.txt

# Adicionar texto ao final do arquivo (append)
!echo "segunda linha" >> arquivo.txt

# Criar scripts com múltiplas linhas
!echo '#!/bin/bash
echo "Ola mundo"
python train.py' > meu_script.sh

Permissões de Arquivos#

No Linux, cada arquivo possui permissões para leitura (r), escrita (w) e execução (x), aplicáveis ao dono, grupo e outros.

# Visualizar permissões
!ls -l script.py
# Saída: -rw-r--r-- 1 user group 1234 Jan 1 12:00 script.py
#        │││ │││ │││
#        │││ │││ └── outros: apenas leitura
#        │││ └───── grupo: apenas leitura
#        └──────── dono: leitura e escrita

Sistema Octal de Permissões (4, 2, 1)

As permissões podem ser representadas por números, onde cada tipo de permissão tem um valor:

Permissão

Símbolo

Valor

Descrição

Leitura

r

4

Permite visualizar o conteúdo do arquivo

Escrita

w

2

Permite modificar o arquivo

Execução

x

1

Permite executar o arquivo como programa

Nenhuma

-

0

Sem permissão

Para definir as permissões, somamos os valores desejados:

Soma

Permissões

Significado

7

rwx (4+2+1)

Leitura + Escrita + Execução

6

rw- (4+2+0)

Leitura + Escrita

5

r-x (4+0+1)

Leitura + Execução

4

r-- (4+0+0)

Apenas Leitura

3

-wx (0+2+1)

Escrita + Execução

2

-w- (0+2+0)

Apenas Escrita

1

--x (0+0+1)

Apenas Execução

0

--- (0+0+0)

Nenhuma permissão

Como ler chmod 755?

chmod 755 = chmod [dono][grupo][outros]
                    7     5      5
                   rwx   r-x    r-x

  • 7 (dono): leitura + escrita + execução

  • 5 (grupo): leitura + execução

  • 5 (outros): leitura + execução

Exemplos comuns:

Código

Permissões

Uso típico

755

rwxr-xr-x

Scripts executáveis, programas

644

rw-r--r--

Arquivos de configuração, documentos

700

rwx------

Arquivos privados do usuário

600

rw-------

Chaves SSH, senhas

777

rwxrwxrwx

Todos podem tudo (evitar!)

Comando

Descrição

Exemplo

chmod +x

Torna arquivo executável

!chmod +x treinar.sh

chmod 755

Dono: rwx, Grupo/Outros: rx

!chmod 755 script.sh

chmod 644

Dono: rw, Grupo/Outros: r

!chmod 644 config.yaml

chown

Altera proprietário do arquivo

!chown usuario:grupo arquivo

Exemplo prático: Criar e executar um script de treinamento:

# Criar script
!echo '#!/bin/bash\npython train.py --epochs 100' > treinar.sh

# Dar permissão de execução
!chmod +x treinar.sh

# Executar
!./treinar.sh

Download de Datasets e Arquivos#

Comando

Descrição

Exemplo

wget

Download direto de URL

!wget https://exemplo.com/dataset.zip

wget -O

Download com nome específico

!wget -O dados.zip https://exemplo.com/arquivo

wget -q

Download silencioso (sem output)

!wget -q https://exemplo.com/modelo.h5

curl -O

Download com curl

!curl -O https://exemplo.com/imagens.tar.gz

curl -L

Seguir redirecionamentos

!curl -L -o dados.zip https://exemplo.com/redirect

Exemplo: Baixar dataset do Kaggle:

# Configurar credenciais do Kaggle
!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json

# Baixar dataset
!kaggle datasets download -d usuario/dataset-name

Compactação e Descompactação#

Comando

Descrição

Exemplo

tar -czvf

Compacta em .tar.gz

!tar -czvf backup.tar.gz pasta/

tar -xzvf

Extrai .tar.gz

!tar -xzvf dataset.tar.gz

tar -xvf

Extrai .tar

!tar -xvf arquivo.tar

zip -r

Compacta em .zip

!zip -r modelos.zip modelos/

unzip

Extrai .zip

!unzip dataset.zip

unzip -q

Extrai silenciosamente

!unzip -q dataset.zip -d dados/

gzip

Compacta arquivo único

!gzip modelo_grande.h5

gunzip

Descompacta .gz

!gunzip modelo_grande.h5.gz

Visualização de Arquivos#

Comando

Descrição

Exemplo

cat

Exibe conteúdo completo

!cat config.yaml

head

Exibe primeiras linhas

!head -n 20 log.txt

tail

Exibe últimas linhas

!tail -n 50 training.log

tail -f

Monitora arquivo em tempo real

!tail -f training.log

less

Navegação interativa (q para sair)

!less arquivo_grande.txt

wc -l

Conta número de linhas

!wc -l dataset.csv

Busca de Arquivos e Conteúdo#

Comando

Descrição

Exemplo

find

Busca arquivos por nome/tipo

!find . -name "*.jpg"

find -type

Busca por tipo (f=arquivo, d=diretório)

!find . -type f -name "*.py"

find -size

Busca por tamanho

!find . -size +100M

grep

Busca texto em arquivos

!grep "error" training.log

grep -r

Busca recursiva em diretórios

!grep -r "learning_rate" .

grep -i

Busca ignorando maiúsculas

!grep -i "warning" log.txt

grep -n

Mostra número da linha

!grep -n "def train" modelo.py

Exemplo: Encontrar todos os modelos salvos maiores que 50MB:

!find . -name "*.h5" -o -name "*.pt" -size +50M

Monitoramento de Disco e Memória#

Comando

Descrição

Exemplo

df -h

Espaço em disco (human-readable)

!df -h

du -sh

Tamanho de pasta/arquivo

!du -sh datasets/

du -sh *

Tamanho de cada item no diretório

!du -sh *

free -h

Uso de memória RAM

!free -h

free -m

Uso de memória em MB

!free -m

Verificar espaço antes de baixar dataset grande:

!echo "=== Espaço em Disco ===" && df -h /
!echo "=== Memória RAM ===" && free -h

Monitoramento de GPU (NVIDIA)#

Para projetos de Deep Learning, monitorar a GPU é essencial:

Comando

Descrição

nvidia-smi

Status completo da GPU (uso, memória, temperatura)

nvidia-smi -l 1

Atualiza a cada 1 segundo

nvidia-smi --query-gpu=...

Consulta campos específicos

watch -n 1 nvidia-smi

Monitoramento contínuo

 
# Status da GPU
!nvidia-smi

# Monitorar apenas uso de memória e GPU
!nvidia-smi --query-gpu=name,memory.used,memory.total,utilization.gpu --format=csv

# Verificar qual GPU está disponível
!nvidia-smi -L

Gerenciamento de Processos#

Comando

Descrição

Exemplo

ps aux

Lista todos os processos

!ps aux

ps aux | grep python

Filtra processos Python

!ps aux | grep python

top

Monitor de processos (interativo)

top

htop

Monitor avançado (se instalado)

htop

kill PID

Encerra processo pelo ID

!kill 12345

kill -9 PID

Força encerramento

!kill -9 12345

killall

Encerra processos pelo nome

!killall python

Redirecionamento e Pipes#

Operador

Descrição

Exemplo

>

Redireciona saída (sobrescreve)

!ls > arquivos.txt

>>

Redireciona saída (anexa)

!echo "fim" >> log.txt

2>

Redireciona erros

!python script.py 2> erros.txt

2>&1

Combina saída e erros

!python train.py > log.txt 2>&1

|

Pipe: saída de um vira entrada de outro

!cat log.txt | grep "loss"

tee

Exibe e salva simultaneamente

!python train.py | tee log.txt

Exemplo completo: Treinar modelo salvando logs e monitorando:

# Executa, salva log completo, e filtra apenas métricas na tela
!python train.py 2>&1 | tee full_log.txt | grep -E "(epoch|loss|accuracy)"

Exercício: Fundamentos de Terminal Linux#

Este exercício prático consolida os comandos básicos de terminal Linux. Você irá criar uma estrutura de projeto, trabalhar com arquivos, configurar permissões, criar e executar um script, e monitorar processos.

Nota: No Google Colab, adicione o prefixo ! antes de cada comando para executá-lo no shell (exemplo: !pwd ao invés de pwd).

Passo 1: Criar estrutura do projeto#

# Verificar onde estamos
pwd

# Criar pasta do projeto com subpastas
mkdir -p meu_projeto/scripts meu_projeto/logs

# Verificar a estrutura criada
ls -la meu_projeto/

Passo 2: Criar arquivos de configuração#

# Criar um arquivo de configuração simples
echo "# Configurações do Projeto" > meu_projeto/config.txt
echo "EPOCHS=100" >> meu_projeto/config.txt
echo "LEARNING_RATE=0.001" >> meu_projeto/config.txt

# Verificar o conteúdo
cat meu_projeto/config.txt

Passo 3: Criar um script Python#

# Criar um script Python simples
echo '#!/usr/bin/env python3
import time
import os

print("=== Meu Primeiro Script ===")
print(f"Diretorio atual: {os.getcwd()}")
print("Processando...")

for i in range(5):
    print(f"Passo {i+1}/5")
    time.sleep(1)

print("Concluido!")
' > meu_projeto/scripts/treinar.py

# Verificar se o arquivo foi criado
cat meu_projeto/scripts/treinar.py

Passo 4: Verificar e ajustar permissões#

# Ver as permissões atuais
ls -l meu_projeto/scripts/treinar.py

# Tornar o script executável
chmod +x meu_projeto/scripts/treinar.py

# Verificar as novas permissões (observe o 'x')
ls -l meu_projeto/scripts/treinar.py

Passo 5: Executar o script#

# Executar o script Python
python meu_projeto/scripts/treinar.py

# Ou executar diretamente (já que demos permissão)
./meu_projeto/scripts/treinar.py

Passo 6: Redirecionar saída para arquivo de log#

# Executar e salvar a saída em um arquivo de log
python meu_projeto/scripts/treinar.py > meu_projeto/logs/saida.log 2>&1

# Verificar o conteúdo do log
cat meu_projeto/logs/saida.log

Passo 7: Monitorar processos#

# Ver processos Python em execução
ps aux | grep python | head -5

# Ver uso de memória
free -h

# Ver espaço em disco
df -h | head -3

Passo 8: Limpeza#

# Listar tudo antes de remover
ls -la meu_projeto/

# Remover o projeto
rm -rf meu_projeto/

# Confirmar que foi removido
ls -la | grep meu_projeto

Desafios extras (complete com ???):

# 1. Criar uma pasta chamada "experimento" com subpasta "dados"
mkdir -p ???

# 2. Copiar o script para a nova pasta (se ainda existir)
cp ??? ???

# 3. Ver apenas os últimos 3 processos do sistema
ps aux | tail -n ???

Desafio Google Drive:

Monte o Google Drive e repita todo o exercício dentro de uma pasta no seu Drive. Assim, seus arquivos persistirão entre sessões do Colab!

# Montar o Google Drive
from google.colab import drive
drive.mount('/content/drive')

# Criar o projeto dentro do Drive
mkdir -p /content/drive/MyDrive/meu_projeto/scripts /content/drive/MyDrive/meu_projeto/logs

# Navegar até a pasta
cd /content/drive/MyDrive/meu_projeto

# Continuar com os passos 2-7 do exercício...

Perguntas de Reflexão:

  1. Qual a diferença entre > e >> ao redirecionar saída?

  2. Por que precisamos usar chmod +x antes de executar um script diretamente?

  3. O que significa a permissão 755 em um arquivo?

  4. Qual a vantagem de trabalhar com arquivos no Google Drive montado?

👁️ Conceitos de Visão Computacional#

A Visão Computacional é um ramo da Ciência da Computação que permite que máquinas processem e interpretem imagens e vídeos, replicando a percepção visual humana. Através de algoritmos avançados, os computadores analisam padrões visuais e extraem informações úteis para diversas aplicações.

Uma das áreas mais conhecidas é o reconhecimento facial, que identifica indivíduos com base em características únicas do rosto. Essa tecnologia está presente em sistemas de segurança, redes sociais e autenticação biométrica. Outra aplicação essencial é a detecção de objetos, utilizada em veículos autônomos e sistemas de vigilância para identificar pedestres, placas e obstáculos em tempo real.

Na área da saúde, a Visão Computacional auxilia na análise de imagens médicas, tornando exames como radiografias e tomografias mais precisos na detecção de doenças. Em segurança, sistemas inteligentes são capazes de monitorar ambientes, reconhecendo atividades suspeitas e alertando operadores sobre possíveis ameaças. Já na realidade aumentada (AR), a tecnologia permite sobrepor elementos virtuais ao mundo real, criando experiências imersivas para jogos, treinamentos e comércio.

Imagem Digital: Pixels, Resolução e Canais de Cor#

Toda imagem digital é composta por pixels, que são as menores unidades visuais. A quantidade total de pixels determina a resolução, expressa como largura × altura (exemplo: 1920×1080), influenciando diretamente a qualidade da imagem.

As cores são representadas por diferentes canais. No modelo RGB (Red, Green, Blue), cada pixel combina três intensidades de cor para formar uma ampla variedade de tons. Essa estrutura permite que computadores processem imagens de forma eficiente e reproduzam cores com fidelidade.

Tipos de Imagens#

As imagens digitais podem ter diferentes representações, dependendo da aplicação. No modelo RGB, cada pixel possui três valores (vermelho, verde e azul), sendo o formato mais comum para fotografias e vídeos. Já as imagens em escala de cinza utilizam apenas tons de preto ao branco, sendo amplamente empregadas em exames médicos e reconhecimento de padrões. Por fim, as imagens binárias contêm apenas dois valores (preto e branco) e são usadas em segmentação de objetos e reconhecimento óptico de caracteres (OCR).

Veja a Ilustração a seguir sobre uma imagem digital.

setup

A seguir, nosso primeiro exemplo prático sobre representação de imagens em diferentes formatos.
Geraremos uma imagem RGB com gradientes de cor, convertê-la-emos para tons de cinza usando o canal verde e, por fim, aplicaremos um limiar para criar uma imagem binária.

O código abaixo demonstra esse processo visualmente.

import numpy as np
import matplotlib.pyplot as plt
import warnings

# Ignorar avisos do Matplotlib para evitar mensagens desnecessárias
warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib")

# Criar uma imagem RGB com gradientes suaves
img_rgb = np.zeros((256, 256, 3), dtype=np.uint8)  # Inicializa uma matriz de zeros (imagem preta) com 3 canais de cor (RGB)

# Preenchendo os canais de cor com gradientes:
img_rgb[:, :, 0] = np.linspace(0, 255, 256, dtype=np.uint8).reshape((256, 1))  # Canal Vermelho (R): varia verticalmente
img_rgb[:, :, 1] = np.linspace(0, 255, 256, dtype=np.uint8).reshape((1, 256))  # Canal Verde (G): varia horizontalmente
img_rgb[:, :, 2] = np.flip(img_rgb[:, :, 1], axis=1)  # Canal Azul (B): inverso do verde, criando um gradiente oposto

# Converter a imagem para tons de cinza usando apenas o canal verde
img_grayscale = img_rgb[:, :, 1]  # Mantemos apenas os valores do canal verde

# Criar uma imagem binária (thresholding) com limiar de 127
img_binary = (img_grayscale > 127).astype(np.uint8) * 255  # Pixels acima do limiar tornam-se brancos (255), os demais pretos (0)

# Criar a figura com 3 subplots para exibir as diferentes representações da imagem
fig, axes = plt.subplots(1, 3, figsize=(12, 4))  # Cria um layout de 1 linha e 3 colunas

# Definição dos títulos e das imagens a serem exibidas
titles = ["RGB", "Grayscale (Canal Verde)", "Binária"]
images = [img_rgb, img_grayscale, img_binary]
cmaps = [None, "gray", "gray"]  # Definição do colormap para cada imagem (apenas grayscale e binária precisam de escala cinza)

# Loop para exibir as imagens nos subplots
for ax, img, title, cmap in zip(axes, images, titles, cmaps):
    ax.imshow(img, cmap=cmap)  # Mostra a imagem
    ax.set_title(title)  # Define o título da imagem
    ax.axis("off")  # Remove os eixos para melhor visualização

# Ajusta o espaçamento entre os gráficos para melhor exibição
plt.tight_layout()
plt.show()  # Exibe as imagens
../../_images/1bd8ad508390b30eaeda5165b4aa931fb5d3cd1f6f9106cfac9255799f68cfa9.png

Processamento Digital de Imagens#

O que é Processamento Digital de Imagens?#

O processamento digital de imagens envolve a aplicação de algoritmos computacionais para modificar, aprimorar ou extrair informações de imagens digitais. Essa área tem um papel fundamental em diversas aplicações, como medicina, segurança, automação e inteligência artificial. As imagens processadas podem ser adquiridas por câmeras digitais, scanners ou sensores especializados, como aqueles usados em exames médicos e sistemas de vigilância.

Principais Etapas do Processamento de Imagens#

O processamento de imagens envolve diversas etapas essenciais, cada uma com objetivos específicos para a manipulação e extração de informação visual.

Aquisição da Imagem#

A etapa inicial consiste na captura da imagem por meio de dispositivos como câmeras digitais, sensores embarcados ou scanners. O resultado é uma imagem digital que servirá como base para as próximas fases do processamento.

Exemplo: Captura de imagens médicas, como tomografias, para análise computacional.

setup

Pré-processamento#

Antes da análise propriamente dita, a imagem precisa ser ajustada para melhorar sua qualidade e reduzir interferências. Essa etapa pode incluir:

  • Remoção de ruído: Uso de filtros espaciais, como o Gaussiano, para eliminar interferências indesejadas.

  • Ajuste de contraste: Realce de detalhes por meio da manipulação da intensidade dos pixels.

  • Equalização de histograma: Redistribui os níveis de cinza para melhorar a visibilidade de padrões.

  • Suavização: Redução de variações abruptas na imagem para minimizar artefatos indesejados.

Exemplo: Aplicação de um filtro Gaussiano para reduzir ruído em imagens biométricas.

setup

Segmentação#

A segmentação divide a imagem em regiões de interesse, isolando objetos do fundo. As principais técnicas incluem:

  • Limiarização (thresholding): Separar pixels com base em um valor de intensidade, gerando uma imagem binária.

  • Segmentação baseada em regiões: Agrupar pixels semelhantes para definir objetos distintos.

  • Detecção de bordas: Identificar contornos de objetos por meio de mudanças abruptas de intensidade.

Exemplo: Uso de limiarização para separar objetos em imagens de exames laboratoriais.

setup

Reconhecimento de Objetos#

Nesta etapa, os objetos previamente segmentados são analisados e classificados. As abordagens mais comuns incluem:

  • Técnicas de aprendizado de máquina: Algoritmos treinados para identificar padrões em imagens.

  • Redes neurais convolucionais (CNNs): Modelos avançados capazes de reconhecer categorias complexas de objetos.

  • Métodos baseados em características: Análise de formas, texturas e padrões presentes na imagem.

Exemplo: Identificação automática de camundongos em experimentos de neurociência.

setup

🔗 Referência: Detecção de camundongos em experimentos

Abrindo uma Imagem com OpenCV#

Antes de realizarmos operações aritméticas com imagens, precisamos aprender a carregar uma imagem utilizando a biblioteca OpenCV. O OpenCV é uma das bibliotecas mais populares para processamento de imagens e visão computacional.

Para abrir uma imagem, utilizamos a função cv2.imread(), que lê o arquivo e o armazena como um array NumPy.

Lembre-se de que o OpenCV carrega imagens no formato BGR (Blue, Green, Red), enquanto outras bibliotecas, como o Matplotlib, utilizam o padrão RGB (Red, Green, Blue). Isso pode causar diferenças na exibição da imagem.

import cv2
import matplotlib.pyplot as plt

# Carregar a imagem
imagem = cv2.imread('imagem_exemplo.png')

# Converter de BGR para RGB (padrão do OpenCV é BGR, mas o Matplotlib usa RGB)
imagem_rgb = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)

# Exibir a imagem
plt.imshow(imagem_rgb)
plt.title('Imagem Carregada')
plt.axis('off')
plt.show()

Explicação do código:
🔹 cv2.imread('imagem_exemplo.png') – Carrega a imagem do arquivo.
🔹 cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB) – Converte a imagem de BGR para RGB para exibição correta no Matplotlib.
🔹 plt.imshow(imagem_rgb) – Exibe a imagem com as cores corretas.

Após carregar a imagem, podemos manipulá-la e aplicar diversas transformações!

📝 Exercício: Baixar, Converter e Adicionar Texto com OpenCV#

Objetivo:
Você deverá baixar uma imagem da internet, convertê-la para escala de cinza, adicionar um texto personalizado e salvar o resultado no Google Drive.

Instruções

  • Baixe uma imagem da web

    • Use requests para baixar uma imagem de uma URL (exemplo: "https://heltonmaia.com/computervision/_images/cover.jpeg").

  • Converta para escala de cinza

    • Aplique cv2.COLOR_BGR2GRAY para transformar a imagem em preto e branco.

  • Adicione um texto à imagem

    • Use cv2.putText() para inserir um texto (ex: "OpenCV Challenge").

    • Defina:

      • Posição ((x, y)).

      • Fonte (cv2.FONT_HERSHEY_SIMPLEX).

      • Escala (1.0).

      • Cor (255 para branco em imagens em cinza).

      • Espessura (2).

  • Exiba a imagem processada

    • Mostre o resultado com cv2.imshow() (ou cv2_imshow no Google Colab).

  • Salve no Google Drive

    • Monte o Drive (drive.mount('/content/drive')).

    • Salve a imagem processada em uma pasta específica.

💡 Dicas Úteis

Posicionamento do texto:

  • Use (50, 50) para colocar o texto no canto superior esquerdo.

Se estiver no Google Colab:

  • Substitua cv2.imshow() por:

from google.colab.patches import cv2_imshow
cv2_imshow(imagem_processada)

Operações Aritméticas com Imagens#

As operações aritméticas com imagens permitem manipular seus valores de pixel de maneira precisa, abrindo um leque de possibilidades para processamento e edição. As operações mais comuns incluem:

Adição: A adição de imagens combina duas imagens somando os valores dos pixels correspondentes. A operação pode ser descrita matematicamente como:

\(I_{\text{resultante}}(x, y) = I_1(x, y) + I_2(x, y)\)

onde \( I_{\text{resultante}}(x, y) \) é o valor do pixel na posição \((x, y)\) da imagem resultante, \( I_1(x, y) \) é o valor do pixel na posição \((x, y)\) da primeira imagem, e \( I_2(x, y) \) é o valor do pixel na posição \((x, y)\) da segunda imagem.

Essa operação é útil para:

  • Combinar informações: Ao adicionar imagens de diferentes fontes, podemos integrar informações e criar uma visão mais completa.

  • Ajustar o brilho: Adicionar um valor constante a todos os pixels aumenta o brilho da imagem.

Exemplo: Adicionar duas imagens e realizar uma combinação de informações.

import numpy as np
import matplotlib.pyplot as plt

# Carregar as imagens
img1 = plt.imread('tropical1.png')
img2 = plt.imread('tropical2.png')

# Verificar se as imagens têm o mesmo tamanho
if img1.shape != img2.shape:
    raise ValueError("As imagens devem ter o mesmo tamanho para adição.")

# Adicionar as imagens
added_img = img1 + img2

# Exibir as imagens lado a lado
fig, axs = plt.subplots(1, 3, figsize=(10, 5))

# Exibir a primeira imagem
axs[0].imshow(img1)
axs[0].set_title('Imagem 1')
axs[0].axis('off')

# Exibir a segunda imagem
axs[1].imshow(img2)
axs[1].set_title('Imagem 2')
axs[1].axis('off')

# Exibir a imagem resultante da adição
axs[2].imshow(added_img)
axs[2].set_title('Imagem Resultante')
axs[2].axis('off')
plt.show()

Baixar tropical1 tropical2

Para evitar a saturação, como poderíamos melhorar o código para obter a imagem abaixo?

Imagem resultante da adição

Subtração: A subtração de imagens calcula a diferença entre os valores dos pixels correspondentes de duas imagens. A operação pode ser descrita matematicamente como:

\( I_{\text{resultante}}(x, y) = I_1(x, y) - I_2(x, y) \)

onde \( I_{\text{resultante}}(x, y) \) é o valor do pixel na posição \((x, y)\) da imagem resultante, \( I_1(x, y) \) é o valor do pixel na posição \((x, y)\) da primeira imagem, e \( I_2(x, y)\) é o valor do pixel na posição \((x, y)\) da segunda imagem.

Essa operação é útil para:

  • Detectar diferenças: A subtração pode destacar as diferenças entre duas imagens, como mudanças ao longo do tempo ou objetos movidos.

  • Isolar elementos: Ao subtrair uma imagem de fundo de uma imagem com um objeto em primeiro plano, podemos isolar o objeto.

Exemplo: Subtrair uma imagem de referência de outra para destacar as alterações ou isolar um objeto. Veja o exemplo a seguir, onde em um cenário sem muitos objetos, existe um sútil movimento de uma mulher caminhando.

import numpy as np
import matplotlib.pyplot as plt

# Carregar as imagens
img1 = plt.imread('w1.png')
img2 = plt.imread('w2.png')

# Subtrair as imagens
subtracted_img = img1 - img2

# Exibir a imagem resultante da subtração
fig, axs = plt.subplots(1, 3, figsize=(10, 5))

# Exibir a primeira imagem
axs[0].imshow(img1)
axs[0].set_title('Imagem 1')
axs[0].axis('off')

# Exibir a segunda imagem
axs[1].imshow(img2)
axs[1].set_title('Imagem 2')
axs[1].axis('off')

# Exibir a imagem resultante da subtração
axs[2].imshow(subtracted_img)
axs[2].set_title('Imagem Resultante')
axs[2].axis('off')
plt.show()

Baixar walking1 walking2

Multiplicação: A multiplicação de imagens pode ser realizada de duas maneiras:

  • Multiplicação por uma constante: Multiplicar uma imagem por uma constante altera o contraste da imagem. Um valor maior aumenta o contraste, enquanto um valor menor o reduz. A operação pode ser descrita matematicamente como:

\( I_{\text{resultante}}(x, y) = c \cdot I(x, y) \)

onde \( I_{\text{resultante}}(x, y) \) é o valor do pixel na posição \((x, y)\) da imagem resultante, \( c \) é a constante multiplicativa, e \( I(x, y) \) é o valor do pixel na posição \((x, y)\) da imagem original.

  • Multiplicação por outra imagem: Multiplicar duas imagens elemento a elemento pode ser usado para aplicar máscaras, onde uma imagem define áreas específicas para serem modificadas na outra imagem. A operação pode ser descrita matematicamente como:

\( I_{\text{resultante}}(x, y) = I_1(x, y) \cdot I_2(x, y) \)

onde \( I_{\text{resultante}}(x, y) \) é o valor do pixel na posição \((x, y)\) da imagem resultante, \( I_1(x, y) \) é o valor do pixel na posição \((x, y)\) da primeira imagem, e \( I_2(x, y) \) é o valor do pixel na posição \((x, y)\) da segunda imagem.

Exemplo: Multiplicar uma imagem por uma constante para aumentar o contraste ou aplicar uma máscara para editar partes específicas da imagem. Utilize uma imagem de sua preferência.

# Multiplicação por uma constante
constant = 1.5
multiplied_img = img1 * constant

# Exibir a imagem resultante da multiplicação por uma constante
fig, axs = plt.subplots(1, 2, figsize=(10, 5))

# Exibir a imagem original
axs[0].imshow(img1)
axs[0].set_title('Imagem Original')
axs[0].axis('off')

# Exibir a imagem resultante da multiplicação
axs[1].imshow(multiplied_img)
axs[1].set_title('Imagem com Contraste Aumentado')
axs[1].axis('off')
plt.show()

Baixar walking1

Manipulação de pixels

# Cortar uma região da imagem
corte = img1[200:, 450:900] # observe a indexação linha x coluna
corte[10:20,100:300] = [0,1,0] # Acessando uma região de pixels e definindo para verde

plt.imshow(corte)

Essas operações básicas são fundamentais para manipulação e análise de imagens, permitindo ajustes precisos e modificações específicas que são essenciais em várias aplicações de Visão Computacional.

🎨 Conversão entre Espaços de Cor#

A conversão entre espaços de cor é essencial em processamento de imagens. O OpenCV (cv2.cvtColor) permite transformar imagens entre diferentes formatos (BGR, Grayscale, HSV, RGB, LAB). Abaixo, exemplos de conversão com visualização lado a lado usando plt.imshow:

Baixar walking3

- Carregar Imagem Original (BGR)

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('w3.png')  # OpenCV carrega em BGR
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Converter para RGB (Matplotlib)
plt.imshow(img_rgb)
plt.title('Original (RGB)')

- Conversões para Outros Espaços de Cor BGR → Grayscale (Escala de Cinza)

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img_rgb), plt.title('Original (RGB)'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_gray, cmap='gray'), plt.title('Grayscale'), plt.axis('off')
plt.tight_layout(), plt.show()

BGR → HSV (Matiz, Saturação, Valor)

img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img_rgb), plt.title('Original (RGB)'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_hsv), plt.title('HSV'), plt.axis('off')
plt.tight_layout(), plt.show()

BGR → LAB (Luminância, Canais A/B)

img_lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img_rgb), plt.title('Original (RGB)'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_lab), plt.title('LAB'), plt.axis('off')
plt.tight_layout(), plt.show()

Visualização de Todos os Espaços de Cores

plt.figure(figsize=(16, 4))
plt.subplot(1, 4, 1), plt.imshow(img_rgb), plt.title('RGB'), plt.axis('off')
plt.subplot(1, 4, 2), plt.imshow(img_gray, cmap='gray'), plt.title('Grayscale'), plt.axis('off')
plt.subplot(1, 4, 3), plt.imshow(img_hsv), plt.title('HSV'), plt.axis('off')
plt.subplot(1, 4, 4), plt.imshow(img_lab), plt.title('LAB'), plt.axis('off')
plt.tight_layout(), plt.show()

Dicas Importantes:

- OpenCV vs Matplotlib:

  • OpenCV usa BGR por padrão; Matplotlib usa RGB. Sempre converta com cv2.COLOR_BGR2RGB antes de exibir no plt.imshow.

- Canais Individuais (HSV/LAB):
Para visualizar canais separados (ex: H, S, V):

h, s, v = cv2.split(img_hsv)
plt.imshow(h, cmap='gray'), plt.title('Canal H (Matiz)'), plt.axis('off'), plt.show()

- Transições Suaves (Vídeo):
Para criar um vídeo de transição entre espaços de cor (como no exemplo do link), use cv2.VideoWriter interpolando os valores de conversão quadro a quadro.

Aproveite que estudou sobre como transitar em diferente canais de cor e tente fazer um vídeo como este do link.

Transformações Geométricas#

As transformações geométricas permitem modificar a posição, orientação e escala de uma imagem. Abaixo, exemplos de translação, rotação, escala, perspectiva e operações aritméticas, seguindo o mesmo padrão de formatação e exibição usado no exemplo de rotação.

- Translação (Deslocamento)
Desloca a imagem nos eixos x e y usando uma matriz de transformação afim:

matriz_translacao = np.float32([[1, 0, deslocamento_x],  # [a, b, tx] → controla eixo X  
                               [0, 1, deslocamento_y]]) # [c, d, ty] → controla eixo Y

Onde:

  • 1 e 0 mantêm a escala original (sem distorção)

  • deslocamento_x e deslocamento_y definem o movimento em pixels

  • Valores positivos: direita/baixo | Valores negativos: esquerda/cima

Exemplo:

import cv2  
import numpy as np  
import matplotlib.pyplot as plt  

img = cv2.imread('w3.png')  
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  

# Aplica translação  
deslocamento_x, deslocamento_y = 50, 100  
matriz_translacao = np.float32([[1, 0, deslocamento_x], [0, 1, deslocamento_y]])
img_transladada = cv2.warpAffine(img, matriz_translacao, (img.shape[1], img.shape[0]))  

# Exibe resultados  
plt.figure(figsize=(12, 6))  
plt.subplot(1, 2, 1), plt.imshow(img), plt.title('Original'), plt.axis('off')  
plt.subplot(1, 2, 2), plt.imshow(img_transladada), plt.title(f'Transladada ({deslocamento_x}, {deslocamento_y})'), plt.axis('off')  
plt.show()

Saída:

  • Imagem original (esquerda) e transladada (direita)

  • Áreas deslocadas além dos limites ficam pretas.

- Rotação
Gira a imagem em torno de um ponto central (cv2.getRotationMatrix2D).

(h, w) = img.shape[:2]
centro = (w // 2, h // 2)
angulo = 45  # Graus
escala = 1.0
matriz_rotacao = cv2.getRotationMatrix2D(centro, angulo, escala)
img_rotacionada = cv2.warpAffine(img, matriz_rotacao, (w, h))

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img), plt.title('Original'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_rotacionada), plt.title(f'Rotacionada ({angulo}°)'), plt.axis('off')
plt.tight_layout()
plt.show()

- Escala (Redimensionamento)
Altera as dimensões da imagem (cv2.resize).

nova_largura, nova_altura = 300, 200  # Novas dimensões (largura, altura)
img_redimensionada = cv2.resize(img, (nova_largura, nova_altura))

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img), plt.title(f'Original ({w}x{h})'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_redimensionada), plt.title(f'Redimensionada ({nova_largura}x{nova_altura})'), plt.axis('off')
plt.tight_layout()
plt.show()

- Transformação de Perspectiva
Muda o ponto de vista da imagem (cv2.getPerspectiveTransform + cv2.warpPerspective).

pontos_originais = np.float32([[50, 50], [200, 50], [50, 200], [200, 200]])
pontos_destino = np.float32([[10, 100], [200, 50], [100, 250], [250, 200]])
matriz_perspectiva = cv2.getPerspectiveTransform(pontos_originais, pontos_destino)
img_perspectiva = cv2.warpPerspective(img, matriz_perspectiva, (w, h))

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1), plt.imshow(img), plt.title('Original'), plt.axis('off')
plt.subplot(1, 2, 2), plt.imshow(img_perspectiva), plt.title('Transformação de Perspectiva'), plt.axis('off')
plt.tight_layout()
plt.show()

Ajuste de Gamma para Clareamento de Imagens com OpenCV e Matplotlib#

O ajuste de gamma é uma técnica fundamental em processamento de imagens para modificar o brilho e contraste de forma não-linear. Esta abordagem é particularmente útil para realçar detalhes em regiões escuras sem afetar excessivamente as áreas claras.

Fundamentos Matemáticos A transformação de gamma segue a equação:

\[ I_{\text{out}} = 255 \times \left(\frac{I_{\text{in}}}{255}\right)^\gamma \]

Onde:

  • \(I_{\text{in}}\): Valor do pixel de entrada (0 a 255)

  • \(\gamma\): Parâmetro de correção

  • \(I_{\text{out}}\): Valor do pixel processado

Efeitos do Parâmetro Gamma

Valor de γ

Efeito na Imagem

Aplicação Típica

γ < 1

Clareamento

Melhorar sombras

γ = 1

Nenhuma alteração

-

γ > 1

Escurecimento

Reduzir áreas superexpostas

Implementação Prática

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Carregar imagem (OpenCV lê em BGR)
img = cv2.imread('w3.png')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Conversão para RGB

# Parâmetros de gamma
gamma_values = [0.4, 1.0, 2.2]  # Exemplos para clarear, original e escurecer

# Configurar plot
plt.figure(figsize=(18, 6))

for i, gamma in enumerate(gamma_values, 1):
    # Aplicar correção de gamma
    corrected = np.power(img_rgb/255., gamma)
    corrected = (corrected * 255).astype(np.uint8)
    
    # Plotar resultados
    plt.subplot(1, 3, i)
    plt.imshow(corrected)
    plt.title(f'γ = {gamma}')
    plt.axis('off')

plt.tight_layout()
plt.show()

Esta abordagem proporciona um controle preciso sobre o realce de imagens, sendo essencial em aplicações como visão computacional, fotografia médica e processamento de vídeo.

📝 Exercício - Processamento de Imagens com Gradio#

Objetivo: Implementar um aplicativo interativo que permita realizar diversas operações de processamento de imagens, incluindo transformações geométricas, manipulação de cores e ajustes de iluminação. O aplicativo deve ser desenvolvido usando uma das bibliotecas indicadas para criar uma interface amigável.

Tarefas a serem implementadas:

  1. Transformações Geométricas

    • Translação: Permitir ao usuário especificar os valores de deslocamento horizontal e vertical.

    • Rotação: Oferecer um controle deslizante para selecionar o ângulo de rotação (0° a 360°).

    • Escala: Incluir opções para ampliar/reduzir a imagem com fatores configuráveis.

  2. Operações de Cores

    • Conversão de espaços de cor: Converter de RGB para Grayscale, HSV e outros.

    • Ajuste de contraste: Multiplicação por constante com controle deslizante para ajuste.

  3. Correção Gamma e Clareamento

    • Controle de gamma: Implementar um controle deslizante para ajustar o valor gamma (0.1 a 3.0).

Lembre-se de permitir que as imagens modificadas possam ser salvas.

Bibliotecas:

🔗 Consulte a documentação do Gradio para implementação: https://gradio.app/docs/

🔗 Consulte a documentação do Streamlit para implementação: https://docs.streamlit.io/

🔗 Consulte a documentação do NiceGUI para implementação: https://nicegui.io/documentation

🧠 Exercícios Conceituais#

1. Explorando a Visão Computacional

Descreva com suas próprias palavras o que é visão computacional.

  • Quais são seus principais objetivos?

  • Por que essa área é considerada estratégica dentro da inteligência artificial?

  • Como ela tem sido aplicada em diferentes áreas do conhecimento e da indústria?

2. Fundamentos da Imagem Digital

O capítulo apresenta os conceitos de pixels, resolução e canais de cor (RGB, escala de cinza, binário).

  • Como a resolução influencia a quantidade de detalhes contidos em uma imagem?

  • De que forma essa característica impacta o desempenho de algoritmos de análise visual?

  • Em que contextos pode ser mais vantajoso utilizar imagens em RGB, tons de cinza ou binárias? Argumente com base em objetivos diferentes de análise.

3. Etapas do Processamento de Imagens

O fluxo do processamento digital de imagens inclui as etapas de aquisição, pré-processamento, segmentação e reconhecimento.

  • Escolha um cenário que envolva análise de imagens (como monitoramento ambiental, inspeção visual, mobilidade urbana etc.).

  • Descreva como essas etapas podem ser aplicadas nesse contexto, destacando o papel de cada uma para alcançar um resultado útil.

4. Bibliotecas Python Essenciais

As bibliotecas NumPy, OpenCV, Matplotlib, Scikit-Image e Pillow são frequentemente utilizadas em projetos de visão computacional.

  • Qual é a principal finalidade de cada uma dessas ferramentas?

  • Aponte situações específicas em que cada biblioteca pode oferecer recursos decisivos para o desenvolvimento de soluções com imagens.

5. Gerenciamento de Dependências com pip

O uso do pip e de arquivos requirements.txt é essencial para organizar ambientes de desenvolvimento.

  • Por que é importante manter um controle claro sobre as bibliotecas e versões utilizadas em um projeto?

  • Que tipos de dificuldades podem surgir quando diferentes membros da equipe ou sistemas operacionais tentam reproduzir um código sem dependências bem definidas?

6. Utilizando Comandos Linux

Imagine que você precisa organizar e preparar um conjunto de imagens no Google Colab usando comandos de terminal.

  • Descrevendo uma sequência de comandos Linux que inclua:

    • Criar uma pasta para armazenar imagens

    • Listar arquivos

    • Mover imagens para essa nova pasta

    • Copiar um conjunto de arquivos para backup

  • Ao final, responda:

    • Como o conhecimento da estrutura de diretórios e do sistema de arquivos do Linux pode ajudar nesse processo?

    • O que são permissões de arquivos no Linux e como elas podem impactar o acesso e manipulação de imagens?

7. Operações Aritméticas com Imagens

Somar ou subtrair imagens pode revelar diferentes tipos de informação.

  • Quando a adição de imagens pode ser vantajosa em análise visual?

  • E a subtração, como pode destacar mudanças ou padrões?

  • Proponha situações em que essas operações seriam especialmente reveladoras.

8. Conversão entre Espaços de Cor

A conversão entre espaços como RGB, Grayscale, HSV e LAB é recorrente em tarefas visuais.

  • Por que diferentes espaços de cor são usados dependendo do problema a ser resolvido?

  • Em que tipo de tarefa a conversão para HSV ou LAB pode facilitar o processamento ou melhorar os resultados?

9. Transformações Geométricas em Imagens

As transformações de imagem — como translação, rotação e escala — são fundamentais para adaptar a imagem ao contexto da análise.

  • Escolha uma situação que envolva múltiplos ângulos, posições ou tamanhos de objetos em uma imagem.

  • Explique como essas transformações ajudam a tornar o sistema mais robusto ou sensível a variações.

10. Ajuste de Gamma em Imagens

O ajuste de gamma modifica a relação entre brilho e contraste na imagem.

  • O que acontece com uma imagem quando usamos um valor de gamma menor que 1? Em que circunstâncias isso é benéfico?

  • E se o valor for maior que 1? Em que situações isso pode melhorar a visualização ou a extração de informações?

Referências e Conteúdo Extra#

Contents