DEV Community: Alexandre Justen Filho

IA Não é Só Chat: o Mundo de Computer Vision, 3D e IA Multimodal

Alexandre Justen Filho — Sun, 30 Aug 2026 05:25:31 +0000

Quando alguém fala em Computer Vision, a primeira coisa que costuma vir à cabeça é detecção de objetos.

É uma parte importante, mas está longe de ser tudo.

Na prática, Computer Vision reúne problemas bem diferentes: entender imagens, acompanhar objetos em vídeo, estimar profundidade, descobrir a posição de uma câmera, reconstruir ambientes em 3D, trabalhar com LiDAR, interpretar documentos e, mais recentemente, conectar visão com modelos de linguagem.

Um sistema mais completo pode ter algo parecido com isto:

Camera / LiDAR / IMU
        ↓
Preprocessing
        ↓
Detection / Segmentation
        ↓
Tracking / Pose
        ↓
Depth / Geometry
        ↓
SfM / MVS / SLAM
        ↓
Point Cloud
        ↓
Mesh / 3D Representation
        ↓
Scene Understanding
        ↓
Vision-Language Model
        ↓
LLM

A ideia deste texto é organizar esse universo de forma prática para quem desenvolve software e quer entender como as peças se encaixam.

1. O mapa geral

Uma forma simples de dividir Computer Vision é:

COMPUTER VISION
│
├── Imagens
│   ├── Classification
│   ├── Detection
│   ├── Segmentation
│   ├── OCR
│   ├── Image Retrieval
│   ├── Image Restoration
│   └── Image Generation
│
├── Vídeo
│   ├── Object Tracking
│   ├── Action Recognition
│   ├── Optical Flow
│   └── Motion Analysis
│
├── Geometria
│   ├── Camera Models
│   ├── Camera Calibration
│   ├── Stereo Vision
│   ├── Depth Estimation
│   ├── Epipolar Geometry
│   ├── SfM
│   ├── MVS
│   └── 3D Reconstruction
│
├── 3D
│   ├── LiDAR
│   ├── Point Clouds
│   ├── Registration
│   ├── SLAM
│   ├── Mesh Reconstruction
│   ├── NeRF
│   ├── Gaussian Splatting
│   └── 3D Object Detection
│
├── Humanos
│   ├── Face Detection
│   ├── Face Recognition
│   ├── Pose Estimation
│   ├── Hand Tracking
│   └── Gesture Recognition
│
└── IA Moderna
    ├── CNN
    ├── Vision Transformers
    ├── Vision-Language Models
    ├── Embeddings
    ├── Multimodal AI
    └── Vision + LLM

O interessante é que essas áreas não ficam isoladas. Em projetos reais, normalmente existe uma combinação delas.

2. Imagem é um tensor

Antes de falar de modelos, vale entender o dado de entrada.

Uma imagem RGB pode ser representada como:

H × W × 3

Por exemplo:

1920 × 1080 × 3

Em frameworks de Deep Learning, é comum encontrar:

[B, C, H, W]

onde:

B = batch;
C = canais;
H = altura;
W = largura.

Uma imagem pode ser vista como uma função:

I(x, y, c)

onde x e y representam a posição do pixel e c o canal.

Parece uma definição simples, mas praticamente todo pipeline de visão começa aqui.

3. Image Processing

Antes de colocar uma imagem em uma rede neural, muitas vezes é necessário prepará-la.

Algumas operações comuns:

resize;
crop;
padding;
normalização;
conversão de espaço de cor;
redução de ruído;
sharpening;
thresholding;
detecção de bordas;
operações morfológicas;
correção de distorção.

Um pipeline básico:

Imagem original
      ↓
Resize
      ↓
Normalização
      ↓
Correção / filtragem
      ↓
Modelo

Bibliotecas muito usadas:

OpenCV
Pillow
NumPy
scikit-image

Nem todo problema precisa de Deep Learning. Em alguns casos, OpenCV resolve praticamente tudo.

4. Classification

Classification responde:

Qual é a classe dessa imagem?

Por exemplo:

Imagem
  ↓
Modelo
  ↓
dog: 0.96
cat: 0.03
horse: 0.01

Formalmente:

P(class | image)

Arquiteturas clássicas:

LeNet;
AlexNet;
VGG;
GoogLeNet;
ResNet;
DenseNet;
EfficientNet;
ConvNeXt;
Vision Transformer.

Classification é normalmente o ponto de entrada para quem começa a estudar visão computacional com Deep Learning.

5. CNNs

As Convolutional Neural Networks foram responsáveis por uma grande parte da evolução inicial do Deep Learning aplicado a imagens.

A convolução percorre a imagem utilizando filtros que aprendem padrões.

De forma simplificada:

Image
  ↓
Convolution
  ↓
Feature Map
  ↓
Activation
  ↓
Pooling
  ↓
More Features
  ↓
Classifier

No começo da rede aparecem padrões mais simples:

edges
corners
textures

Nas camadas seguintes:

shapes
parts
objects

E no final:

semantic representation

6. Object Detection

Classification diz o que existe.

Detection também precisa dizer onde.

Uma saída típica contém:

class
confidence
x1
y1
x2
y2

Ou:

class
confidence
center_x
center_y
width
height

Visualmente:

┌──────────────────────────────┐
│                              │
│    ┌───────────────┐         │
│    │    person     │         │
│    └───────────────┘         │
│                              │
│                  ┌────────┐  │
│                  │  car   │  │
│                  └────────┘  │
│                              │
└──────────────────────────────┘

7. Object Detection: principais abordagens

Two-stage detectors

Exemplos:

R-CNN
Fast R-CNN
Faster R-CNN
Mask R-CNN

A ideia geral:

Image
 ↓
Region Proposals
 ↓
Classification
 ↓
Bounding Box Refinement

One-stage detectors

Exemplos:

YOLO
SSD
RetinaNet

A ideia:

Image
 ↓
Neural Network
 ↓
Boxes + Classes + Confidence

Essa abordagem costuma ser muito interessante quando existe requisito de tempo real.

Transformer-based detectors

Um exemplo conhecido é o DETR.

Aqui a detecção é formulada de uma maneira diferente, usando a arquitetura Transformer para prever os objetos.

8. IoU e NMS

Detection gera muitas previsões.

Duas bounding boxes podem representar o mesmo objeto.

Para medir a sobreposição, usamos IoU:

IoU = Intersection / Union

Quanto mais próximo de 1, maior a sobreposição.

Depois, algoritmos como Non-Maximum Suppression (NMS) ajudam a remover previsões duplicadas.

Uma versão simplificada:

Detections
   ↓
Ordenar por confidence
   ↓
Escolher melhor box
   ↓
Comparar IoU
   ↓
Remover duplicatas

9. Segmentation

Detection trabalha com bounding boxes.

Segmentation trabalha em nível de pixel.

Semantic Segmentation

Cada pixel recebe uma classe:

pixel → class

Por exemplo:

road
car
person
sky
building

Instance Segmentation

Aqui cada objeto é uma instância separada:

person #1
person #2
person #3

Mesmo todos pertencendo à classe person.

Panoptic Segmentation

Combina semantic segmentation e instance segmentation para representar a cena de forma mais completa.

10. Segment Anything

Modelos como SAM popularizaram uma abordagem mais geral para segmentação.

Em vez de ter um modelo treinado exclusivamente para uma classe específica, podemos fornecer diferentes tipos de prompt.

Por exemplo:

point
box
mask
text

Um pipeline pode ser:

Imagem
  ↓
Prompt
  ↓
Segmentation Model
  ↓
Mask

Isso é útil para ferramentas interativas, edição de imagens e pipelines de anotação.

11. OCR

OCR significa Optical Character Recognition.

O objetivo é transformar texto presente em pixels em texto digital.

Um pipeline tradicional:

Image
 ↓
Preprocessing
 ↓
Text Detection
 ↓
Text Recognition
 ↓
Post-processing
 ↓
Text

Por exemplo:

Imagem de documento
       ↓
"NOTA FISCAL"
"VALOR: R$ 1.250,00"
"CNPJ: ..."

OCR moderno pode combinar CNNs, LSTMs, Transformers e modelos multimodais.

12. Document AI

OCR resolve apenas uma parte do problema.

Um documento real também possui layout, tabelas, campos e relações entre informações.

Um pipeline de Document AI pode ser:

Document
   ↓
OCR
   ↓
Layout Analysis
   ↓
Entity Extraction
   ↓
Document Understanding

O sistema pode identificar:

invoice_number
customer
company
date
total
tax
items

Isso aparece bastante em automação de processos, sistemas financeiros, jurídico e governo.

13. Image Retrieval

Outra aplicação é encontrar imagens semelhantes.

A ideia moderna é transformar uma imagem em um embedding:

Image
  ↓
Vision Encoder
  ↓
Embedding

Por exemplo:

[0.12, -0.81, 0.43, 0.19, ...]

Depois armazenamos esses vetores e fazemos busca por similaridade.

Query Image
     ↓
Embedding
     ↓
Vector Database
     ↓
Nearest Neighbors
     ↓
Similar Images

Tecnologias comuns:

FAISS
Qdrant
Milvus
Weaviate
pgvector

14. Vídeo

Um vídeo é uma sequência temporal:

Frame 1
Frame 2
Frame 3
...
Frame N

Então temos duas dimensões importantes:

spatial information
+
temporal information

É isso que torna vídeo mais complicado que uma imagem isolada.

15. Object Tracking

Detection identifica objetos.

Tracking tenta manter a identidade desses objetos ao longo dos frames.

Frame 1 → person #17
Frame 2 → person #17
Frame 3 → person #17
Frame 4 → person #17

Assim podemos obter uma trajetória:

(x1, y1)
(x2, y2)
(x3, y3)
...

Algumas abordagens conhecidas:

Kalman Filter
SORT
DeepSORT
ByteTrack
BoT-SORT

16. Optical Flow

Optical Flow tenta estimar o movimento aparente dos pixels entre frames.

Um vetor pode ser representado por:

u(x,y)
v(x,y)

O resultado é um campo de movimento:

→ → →
→ → →
→ → →

Aplicações:

motion estimation;
estabilização de vídeo;
tracking;
action recognition;
robótica.

17. Action Recognition

Agora o objetivo não é apenas descobrir que existe uma pessoa.

Queremos descobrir o que ela está fazendo:

walking
running
jumping
falling
sitting

Isso exige informação temporal.

Arquiteturas podem utilizar:

CNN + RNN
3D CNN
Video Transformer

18. Motion Analysis

Depois de detectar e acompanhar objetos, podemos analisar:

trajetória;
velocidade;
direção;
aceleração;
interação entre objetos;
comportamento temporal.

Um pipeline:

Video
 ↓
Detection
 ↓
Tracking
 ↓
Trajectory
 ↓
Motion Analysis
 ↓
Event Detection

É uma base para aplicações como monitoramento, análise esportiva e robótica.

19. Camera Model

Para entrar em visão 3D, precisamos entender como uma câmera transforma o mundo 3D em uma imagem 2D.

Um ponto:

P = (X, Y, Z)

pode ser projetado aproximadamente como:

x = fX/Z
y = fY/Z

onde f representa a distância focal.

Uma câmera real normalmente é representada por uma matriz intrínseca:

K =
[ fx  0  cx ]
[ 0  fy  cy ]
[ 0   0   1 ]

Isso aparece constantemente em reconstrução 3D.

20. Camera Calibration

Calibration determina os parâmetros da câmera.

Intrinsics

Exemplos:

fx
fy
cx
cy
k1
k2
k3
p1
p2

Os primeiros representam parâmetros internos da câmera e os demais podem representar distorção.

Extrinsics

Representam a pose da câmera:

R
t

onde:

R = rotation
t = translation

Uma transformação pode ser escrita como:

P_camera = R P_world + t

21. Lens Distortion

Lentes reais introduzem distorções.

As mais conhecidas:

radial distortion
tangential distortion

Um pipeline pode começar com:

Distorted Image
      ↓
Undistortion
      ↓
Rectified Image

Isso é especialmente importante em aplicações geométricas.

22. Stereo Vision

Duas câmeras permitem estimar profundidade.

Left Camera             Right Camera
      \                     /
       \                   /
        \                 /
             Object

A diferença entre a posição de um ponto nas duas imagens é a disparidade:

disparity = d

Uma relação simplificada:

Z = fB / d

onde:

Z = profundidade
f = focal length
B = baseline
d = disparity

Quanto maior a disparidade, normalmente menor a distância do objeto.

23. Depth Estimation

Depth estimation tenta produzir um mapa de profundidade.

Entrada:

RGB Image

Saída:

Depth Map

Pode ser:

monocular;
stereo;
RGB-D;
baseado em sensores;
baseado em múltiplas imagens.

Representação:

RGB
 ↓
Depth Network
 ↓
Depth Map

Modelos modernos utilizam arquiteturas profundas, inclusive Transformers.

24. Epipolar Geometry

Em stereo e reconstrução 3D, epipolar geometry é fundamental.

Um ponto em uma imagem não corresponde a qualquer lugar da segunda imagem. Ele está restrito a uma linha epipolar.

Conceitos importantes:

Fundamental Matrix
Essential Matrix
Epipoles
Epipolar Lines

Uma relação clássica:

x'ᵀ F x = 0

onde F é a Fundamental Matrix.

25. Feature Detection

Para reconstruir uma cena a partir de imagens, precisamos encontrar pontos que possam ser reconhecidos em diferentes views.

Algoritmos clássicos:

SIFT
SURF
ORB
AKAZE

Um feature normalmente envolve:

keypoint
+
descriptor

O keypoint representa a localização.

O descriptor representa as características daquela região.

26. Feature Matching

Depois de extrair features de duas imagens:

Image A
  ↓
Descriptors A

Image B
  ↓
Descriptors B

podemos procurar correspondências:

A[124] ↔ B[87]
A[233] ↔ B[152]
A[901] ↔ B[421]

Esses matches são a matéria-prima de muitos pipelines de reconstrução.

27. RANSAC

Nem todo match é correto.

Alguns são outliers.

RANSAC é usado para estimar modelos geométricos de forma robusta.

Matches
  ↓
RANSAC
  ↓
Inliers + Outliers

Os inliers são usados para estimar uma transformação ou modelo geométrico mais confiável.

28. Structure from Motion

SfM, ou Structure from Motion, tenta recuperar:

camera poses
+
3D structure

a partir de várias imagens.

Um pipeline simplificado:

Images
  ↓
Feature Extraction
  ↓
Feature Matching
  ↓
Camera Pose Estimation
  ↓
Triangulation
  ↓
Sparse Point Cloud

A grande vantagem é que não precisamos necessariamente de um sensor de profundidade dedicado.

A geometria pode ser recuperada a partir das imagens.

29. Triangulation

Se temos:

Camera A
Camera B

e um mesmo ponto aparece nas duas imagens, podemos estimar sua posição 3D.

Camera A
    \
     \
      P
     /
    /
Camera B

Esse processo é chamado de triangulação.

O resultado é um ponto no espaço:

P = (X, Y, Z)

30. Bundle Adjustment

Durante SfM, as estimativas iniciais podem conter erros.

Bundle Adjustment otimiza simultaneamente:

camera poses
+
3D points

buscando minimizar o erro de reprojeção.

Conceitualmente:

minimize Σ || observed_pixel - projected_3D_point ||²

Esse tipo de otimização é uma das partes mais importantes de um pipeline de reconstrução fotogramétrica.

31. Multi-View Stereo

SfM normalmente produz uma reconstrução esparsa.

MVS tenta gerar uma reconstrução muito mais densa.

SfM
 ↓
Sparse Point Cloud
 ↓
MVS
 ↓
Dense Point Cloud

Uma maneira útil de pensar:

SfM = entender câmeras + estrutura inicial

MVS = recuperar geometria densa

32. Fotogrametria

Um pipeline de fotogrametria pode ser:

Photos
 ↓
Feature Extraction
 ↓
Feature Matching
 ↓
Camera Calibration
 ↓
SfM
 ↓
Sparse Reconstruction
 ↓
MVS
 ↓
Dense Point Cloud
 ↓
Surface Reconstruction
 ↓
Mesh
 ↓
Texture

Ferramentas conhecidas:

COLMAP
OpenMVG
OpenMVS
AliceVision / Meshroom
Open3D

33. Point Clouds

Uma Point Cloud é um conjunto de pontos 3D.

O mínimo:

X
Y
Z

Mas um ponto pode carregar muito mais informação:

X
Y
Z
R
G
B
normal
intensity
confidence
timestamp

Por exemplo:

P1 = (1.2, 0.4, 2.1)
P2 = (1.3, 0.5, 2.0)
P3 = (1.4, 0.5, 2.2)

34. Point Cloud Registration

Se temos duas nuvens:

Cloud A
Cloud B

precisamos encontrar a transformação que alinha uma com a outra.

Um algoritmo clássico é o ICP:

Iterative Closest Point

Pipeline:

Initial Alignment
      ↓
Nearest Neighbors
      ↓
Estimate Transform
      ↓
Apply Transform
      ↓
Repeat

A transformação normalmente pertence ao grupo de movimentos rígidos:

T ∈ SE(3)

35. LiDAR

LiDAR significa Light Detection and Ranging.

O princípio básico é medir o tempo que a luz leva para ir até uma superfície e retornar.

Uma aproximação:

d = cΔt / 2

onde:

d  = distância
c  = velocidade da luz
Δt = tempo de voo

O sensor pode gerar uma representação 3D do ambiente.

36. LiDAR + Camera

Câmera e LiDAR têm características diferentes.

A câmera oferece:

color
texture
semantic information

O LiDAR oferece:

depth
geometry

Com calibração entre os dois sensores, podemos projetar pontos do LiDAR na imagem.

LiDAR Point
     ↓
Extrinsic Transform
     ↓
Camera Coordinate System
     ↓
Pixel Projection

Isso permite, por exemplo, associar cor RGB a pontos 3D.

37. SLAM

SLAM significa:

Simultaneous Localization and Mapping

O sistema precisa resolver duas coisas ao mesmo tempo:

Onde estou?

Como é o ambiente?

Pipeline simplificado:

Sensor
  ↓
Feature / Point Extraction
  ↓
Motion Estimation
  ↓
Pose
  ↓
Map Update
  ↓
Loop Closure

Aplicações:

robótica;
AR;
VR;
drones;
navegação;
mapeamento.

38. Visual SLAM

No Visual SLAM, câmeras são usadas para estimar movimento e construir o mapa.

Alguns sistemas conhecidos:

ORB-SLAM
ORB-SLAM2
ORB-SLAM3
VINS
OpenVSLAM

A qualidade depende bastante de fatores como textura, iluminação, movimento e características da câmera.

39. Visual-Inertial SLAM

Podemos combinar câmera e IMU:

Camera
+
IMU

A IMU normalmente fornece:

accelerometer
gyroscope

Os sensores podem ser combinados:

Camera ─────┐
            ├──> Sensor Fusion ──> Pose
IMU ────────┘

Isso ajuda principalmente em movimentos rápidos e cenários onde a imagem sozinha é insuficiente.

40. Mesh Reconstruction

Point cloud não é necessariamente uma superfície.

Uma mesh possui:

vertices
edges
faces

Normalmente utilizamos triângulos:

Triangle Mesh

Pipeline:

Point Cloud
 ↓
Surface Reconstruction
 ↓
Mesh

41. Poisson Surface Reconstruction

Poisson Surface Reconstruction é um método bastante conhecido para transformar pontos orientados em uma superfície.

Point Cloud
+
Normals
 ↓
Poisson Reconstruction
 ↓
Surface
 ↓
Triangle Mesh

A qualidade das normais e da densidade da nuvem influencia bastante o resultado.

42. TSDF

TSDF significa Truncated Signed Distance Function.

A ideia é integrar várias observações de profundidade em um volume.

Depth Frame 1
Depth Frame 2
Depth Frame 3
...
Depth Frame N
        ↓
    TSDF Volume
        ↓
Surface Extraction
        ↓
Mesh

Essa técnica aparece em vários sistemas de reconstrução RGB-D.

43. NeRF

NeRF significa Neural Radiance Fields.

Em vez de representar uma cena apenas com pontos ou polígonos, o sistema aprende uma representação neural.

De forma simplificada:

(x, y, z, direction)
          ↓
    Neural Network
          ↓
 density + color

Depois podemos renderizar a cena a partir de diferentes posições de câmera.

A ideia geral:

Camera Ray
    ↓
Sample Points
    ↓
Neural Field
    ↓
Volume Rendering
    ↓
Pixel

44. Gaussian Splatting

3D Gaussian Splatting segue outra abordagem para representar uma cena.

Em vez de uma mesh tradicional, a cena é composta por gaussianas 3D.

Uma gaussiana pode carregar:

position
scale
rotation
opacity
color

Pipeline:

Scene
 ↓
3D Gaussians
 ↓
Rasterization
 ↓
Rendered Image

É uma técnica especialmente interessante para visualização e reconstrução de cenas.

45. 3D Object Detection

Detection também pode acontecer diretamente no espaço 3D.

Entrada:

Point Cloud

Saída:

3D Bounding Box

Uma bounding box 3D pode conter:

x
y
z
width
height
depth
rotation
class
confidence

Isso aparece bastante em:

veículos autônomos;
robótica;
logística;
ambientes industriais.

46. Face Detection

Face Detection responde:

Onde existem rostos?

Normalmente produz bounding boxes.

Image
 ↓
Face Detector
 ↓
Bounding Boxes

Isso é diferente de reconhecimento facial.

47. Face Recognition

Recognition tenta gerar uma representação que permita comparar rostos.

Pipeline:

Face Detection
 ↓
Face Alignment
 ↓
Face Embedding
 ↓
Similarity

O rosto vira um vetor:

[0.13, -0.44, 0.82, ...]

E podemos comparar embeddings usando medidas de distância ou similaridade.

48. Pose Estimation

Pose Estimation tenta localizar partes do corpo.

Exemplo:

head
shoulder
elbow
wrist
hip
knee
ankle

Uma saída 2D pode ser:

(x, y, confidence)

Em 3D:

(x, y, z)

Isso permite aplicações de:

análise esportiva;
realidade aumentada;
interação humano-computador;
animação;
robótica.

49. Hand Tracking

Mãos podem ser representadas por landmarks.

Um modelo pode retornar dezenas de pontos:

landmark
    ├── x
    ├── y
    ├── z
    └── confidence

Com esses pontos podemos construir reconhecimento de gestos.

Camera
 ↓
Hand Detection
 ↓
Landmarks
 ↓
Gesture Classification

50. Vision Transformers

Transformers mudaram primeiro o NLP e depois passaram a dominar uma parte importante da visão computacional.

No caso do Vision Transformer:

Image
 ↓
Patch Extraction
 ↓
Patch Embeddings
 ↓
Transformer
 ↓
Visual Representation

Uma imagem pode ser dividida em patches.

Por exemplo:

224 × 224

com patches de:

16 × 16

resulta em:

14 × 14 = 196 patches

Esses patches podem ser tratados como uma sequência de tokens visuais.

51. Self-Attention

O mecanismo de atenção permite que diferentes partes da imagem sejam relacionadas entre si.

A operação básica é:

Attention(Q, K, V)
=
softmax(QKᵀ / √d)V

Isso ajuda o modelo a capturar relações de longo alcance.

Em comparação com convoluções, a atenção oferece uma maneira diferente de modelar dependências espaciais.

52. CNN vs Vision Transformer

Característica	CNN	Vision Transformer
Operação principal	Convolução	Attention
Viés espacial	Forte	Mais flexível
Relações locais	Muito boas	Aprendidas
Relações globais	Mais limitadas	Muito fortes
Escalabilidade	Alta	Muito alta
Uso atual	Muito relevante	Muito relevante

Não existe uma regra simples de que um substituiu completamente o outro. Ambos continuam sendo usados.

53. Vision-Language Models

Vision-Language Models conectam visão e linguagem.

Um modelo pode receber:

Image
+
Question

e produzir:

Answer

Ou:

Image
 ↓
Description

A ideia é criar uma representação compartilhada ou conectada entre conteúdo visual e linguagem.

Isso abre espaço para sistemas que conseguem conversar sobre imagens.

54. Multimodal AI

Multimodal vai além de imagem + texto.

Um sistema pode trabalhar com:

Image
Video
Audio
Text
3D
Sensors

Conceitualmente:

Image Encoder ───┐
Video Encoder ───┤
Audio Encoder ───┼──> Multimodal Representation
Text Encoder ────┤
3D Encoder ──────┘

Esse tipo de arquitetura é particularmente interessante quando o problema não pode ser resolvido olhando apenas para um tipo de dado.

55. Vision + LLM

Uma arquitetura cada vez mais comum:

Camera
 ↓
Vision Encoder
 ↓
Visual Features
 ↓
LLM
 ↓
Reasoning
 ↓
Action

Por exemplo:

Camera
 ↓
Detection
 ↓
Scene Understanding
 ↓
Vision-Language Model
 ↓
LLM
 ↓
"Existe um obstáculo aproximadamente 2 metros à frente."

Aqui a visão deixa de ser apenas uma etapa de classificação e passa a fazer parte de um sistema de raciocínio.

56. Embeddings visuais

Embeddings são uma das peças importantes dos sistemas modernos.

Image
 ↓
Encoder
 ↓
Vector

Depois podemos usar o vetor para:

busca;
clustering;
classificação;
recomendação;
retrieval;
comparação;
RAG multimodal.

Um exemplo:

Query Image
      ↓
Embedding
      ↓
Vector Database
      ↓
Similar Content
      ↓
LLM / Application

57. RAG multimodal

RAG tradicional costuma trabalhar com texto.

Em uma arquitetura multimodal, podemos recuperar:

documents
images
tables
diagrams
photos

Pipeline:

User Question
      ↓
Query Embedding
      ↓
Vector Search
      ↓
Relevant Images + Documents
      ↓
Multimodal Model
      ↓
Answer

Isso pode ser usado para manuais técnicos, documentação, inspeções, plantas, contratos e outros conteúdos.

58. Sensor Fusion

Sistemas avançados raramente precisam depender de um único sensor.

Podemos combinar:

Camera
LiDAR
Radar
IMU
GPS
Depth Sensor

A arquitetura:

Camera ───┐
LiDAR ────┤
Radar ────┼──> Sensor Fusion
IMU ──────┤
GPS ──────┘
                ↓
            World Model

Cada sensor tem pontos fortes e limitações.

A fusão tenta obter uma representação mais confiável do ambiente.

59. Computer Vision em veículos autônomos

Um perception stack pode ser:

Cameras
LiDAR
Radar
IMU
   ↓
Sensor Fusion
   ↓
Object Detection
   ↓
Tracking
   ↓
Depth / 3D Perception
   ↓
Localization
   ↓
Scene Understanding
   ↓
Planning

A visão é apenas uma parte do sistema inteiro.

60. Computer Vision em robótica

Um robô precisa perceber o ambiente antes de tomar decisões.

Um pipeline possível:

Sensors
 ↓
Perception
 ↓
Localization
 ↓
Mapping
 ↓
Planning
 ↓
Control

A percepção pode envolver:

Detection
Segmentation
Depth
SLAM
3D Reconstruction
Pose Estimation

61. Augmented Reality

AR depende bastante de entender a relação entre câmera e mundo.

Um pipeline típico:

Camera
 ↓
Tracking
 ↓
SLAM
 ↓
Plane Detection
 ↓
World Tracking
 ↓
Virtual Object Placement

Sem uma estimativa razoável da pose da câmera, objetos virtuais não conseguem permanecer corretamente posicionados no ambiente.

62. 3D Scanning

Um scanner 3D é um ótimo exemplo de como várias áreas se juntam.

Podemos ter:

Camera
+
LiDAR
+
IMU

e um pipeline:

Capture
 ↓
Frame Selection
 ↓
Image Quality
 ↓
Feature Extraction
 ↓
Feature Matching
 ↓
Camera Pose
 ↓
Depth
 ↓
Point Cloud
 ↓
Registration
 ↓
Dense Reconstruction
 ↓
Mesh
 ↓
Texture
 ↓
3D Model

Aqui aparecem praticamente todos os conceitos discutidos anteriormente.

63. Captura de imagens para reconstrução

Mais imagens não significa necessariamente uma reconstrução melhor.

Alguns fatores importantes:

sharpness
exposure
overlap
texture
viewpoint diversity
motion blur
lighting
camera calibration

Se uma imagem estiver muito borrada, os features podem ser ruins.

Se houver pouca sobreposição entre duas imagens, o matching pode falhar.

Se todas as imagens forem praticamente iguais, também pode faltar informação geométrica.

64. Frame Selection

Em uma aplicação de captura contínua, não é necessário guardar todos os frames.

Podemos avaliar:

blur score
feature count
motion
image quality
overlap
pose change

Por exemplo:

Quality < threshold
    → discard

Feature count < threshold
    → discard

Pose change muito pequeno
    → skip

Motion muito alto
    → wait

Isso reduz processamento, armazenamento e tráfego de rede.

65. Edge AI

Nem todo processamento precisa acontecer no servidor.

Podemos dividir o pipeline:

Mobile
 ├── Capture
 ├── Preprocessing
 ├── Detection
 ├── Tracking
 └── Quality Control

Server
 ├── SfM
 ├── MVS
 ├── Reconstruction
 └── Heavy Inference

Essa arquitetura pode reduzir:

latency
bandwidth
server load

e em determinados cenários também pode ajudar com privacidade.

66. CPU vs GPU

Computer Vision moderno pode ser bastante pesado.

CPU é muito útil para:

I/O;
lógica;
pré-processamento;
serialização;
pós-processamento.

GPU é especialmente boa para:

convoluções;
Transformers;
operações matriciais;
treinamento;
inferência paralela.

Um pipeline pode ser:

CPU
 ↓
Data Preparation
 ↓
GPU
 ↓
Inference
 ↓
CPU
 ↓
Post-processing

67. Frameworks

Um stack bastante comum:

Python

Python
NumPy
OpenCV
PyTorch
scikit-image

Computer Vision

OpenCV
MediaPipe
Open3D
PCL

3D / Photogrammetry

COLMAP
OpenMVG
OpenMVS
Meshroom
Open3D

Deep Learning

PyTorch
TensorFlow
ONNX
TensorRT

Mobile

ARKit
Vision
Core ML
TensorFlow Lite
ONNX Runtime

68. OpenCV

OpenCV continua sendo uma das bibliotecas mais importantes da área.

Ela oferece ferramentas para:

image processing
feature detection
camera calibration
stereo vision
optical flow
video processing
geometric transformations

Mesmo quando o modelo de IA é desenvolvido em PyTorch, OpenCV frequentemente aparece em outras partes do pipeline.

69. Open3D

Open3D é especialmente útil para aplicações 3D.

Pode trabalhar com:

Point Clouds
Meshes
RGB-D
Registration
Visualization
Surface Reconstruction

Um pipeline típico:

RGB-D
 ↓
Point Cloud
 ↓
Registration
 ↓
Fusion
 ↓
Mesh

70. COLMAP

COLMAP é uma das ferramentas mais conhecidas para reconstrução 3D a partir de imagens.

Um pipeline típico:

Images
 ↓
Feature Extraction
 ↓
Feature Matching
 ↓
SfM / Mapper
 ↓
Sparse Reconstruction
 ↓
Dense Reconstruction
 ↓
Point Cloud

É uma ferramenta importante para quem trabalha com:

photogrammetry
SfM
MVS
3D reconstruction

71. Avaliação de modelos

Um modelo não deve ser avaliado apenas olhando alguns resultados.

É necessário usar métricas.

Classification

Accuracy
Precision
Recall
F1
Top-k Accuracy

Detection

IoU
Precision
Recall
mAP

Segmentation

IoU
Dice
Pixel Accuracy

Tracking

MOTA
MOTP
IDF1
HOTA

72. Confusion Matrix

Para classificação:

                 Predicted
              Cat       Dog

Actual Cat     TP        FN

Actual Dog     FP        TP

A partir disso:

Precision = TP / (TP + FP)

Recall = TP / (TP + FN)

F1 = 2 × Precision × Recall
     ------------------------
     Precision + Recall

73. IoU

IoU é utilizado principalmente em detection e segmentation.

IoU = Intersection / Union

Exemplo conceitual:

Prediction
┌───────────────┐
│               │
│    ┌──────────┼────┐
│    │          │    │
└────┼──────────┘    │
     └───────────────┘
      Ground Truth

Quanto maior a interseção relativa, melhor a sobreposição.

74. mAP

Mean Average Precision é uma métrica muito usada em object detection.

Ela envolve a relação entre:

Precision
Recall
IoU

É comum encontrar:

mAP@50
mAP@50:95

É importante observar exatamente qual métrica está sendo reportada antes de comparar dois modelos.

75. Latência e FPS

Em aplicações reais, accuracy não é tudo.

Também precisamos medir:

Latency
FPS
Memory
GPU utilization
Power consumption

Um modelo muito preciso pode não servir para uma aplicação que exige tempo real.

Por exemplo:

30 FPS

significa aproximadamente:

33 ms por frame

Então todo o pipeline precisa caber nesse orçamento de tempo.

76. Quantization

Modelos podem ser quantizados:

FP32
 ↓
FP16
 ↓
INT8

Isso pode reduzir:

memory
latency
power consumption

mas pode haver perda de precisão dependendo do modelo e da estratégia utilizada.

77. Outras otimizações

Algumas técnicas:

Pruning
Knowledge Distillation
Quantization
Operator Fusion
ONNX
TensorRT
Compilation

Um pipeline de deployment pode ser:

Training Model
      ↓
Export
      ↓
Optimization
      ↓
Quantization
      ↓
Compilation
      ↓
Deployment

78. Model Deployment

O modelo pode rodar em:

Cloud
Server
Desktop
Edge Device
Mobile
Embedded Hardware

Um exemplo híbrido:

Mobile Camera
      ↓
On-device Model
      ↓
Local Filtering
      ↓
API
      ↓
Backend
      ↓
Heavy Model

A arquitetura depende de latência, custo, hardware, conectividade e privacidade.

79. Dados

Um dos maiores erros ao começar em Machine Learning é assumir que o modelo é a parte mais importante.

Na prática, a qualidade dos dados tem enorme impacto.

Problemas comuns:

dataset pequeno
labels ruins
classes desbalanceadas
lighting diferente
camera diferente
resolution diferente
domain shift

Um modelo excelente treinado com dados ruins continuará produzindo resultados ruins.

80. Data Augmentation

Durante o treinamento podemos variar os dados:

rotation
crop
flip
scale
brightness
contrast
noise
blur
perspective
color jitter

Por exemplo:

Original
   ↓
Augmentation
   ↓
Training Samples

A ideia é tornar o modelo menos dependente de condições específicas do dataset.

81. Domain Shift

Um modelo treinado em um ambiente pode se comportar de maneira completamente diferente em outro.

Por exemplo:

Training:
studio lighting

Production:
outdoor lighting

Ou:

Training:
high-end camera

Production:
mobile camera

Esse problema é conhecido como domain shift.

É uma das razões pelas quais modelos que parecem excelentes em benchmarks podem precisar de ajustes quando chegam à produção.

82. Perception Stack

Podemos juntar várias dessas ideias em uma arquitetura:

                    SENSORS
                       │
       ┌───────────────┼───────────────┐
       ▼               ▼               ▼
    Camera            LiDAR           IMU
       │               │               │
       └───────────────┼───────────────┘
                       ▼
                 Sensor Fusion
                       │
                       ▼
                Object Detection
                       │
                       ▼
                    Tracking
                       │
                       ▼
                 Depth / 3D
                       │
                       ▼
                  Localization
                       │
                       ▼
               Scene Understanding
                       │
                       ▼
                   World Model
                       │
                       ▼
                    Decision

Essa arquitetura aparece, com variações, em robótica, veículos autônomos, AR e sistemas de mapeamento.

83. Spatial Intelligence

Existe uma evolução interessante quando passamos de reconhecimento para entendimento espacial.

Primeiro:

"Existe uma cadeira."

Depois:

"A cadeira está a 2 metros."

Depois:

"A cadeira está à esquerda e está orientada nessa direção."

E finalmente:

"Existe espaço suficiente para passar ao lado da cadeira."

O sistema deixa de apenas classificar objetos e começa a construir uma representação do ambiente.

Isso aproxima Computer Vision de conceitos como:

3D perception
spatial reasoning
world models
robotics
multimodal AI

84. Um pipeline completo de visão + 3D + IA

Uma arquitetura mais ambiciosa poderia ser:

                    WORLD
                      │
                      ▼
                 ┌─────────┐
                 │ Sensors │
                 └────┬────┘
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
       Camera       LiDAR        IMU
          │           │           │
          └───────────┼───────────┘
                      ▼
                Preprocessing
                      │
                      ▼
              Computer Vision
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
    Detection     Segmentation    Tracking
        │             │             │
        └─────────────┼─────────────┘
                      ▼
                  Geometry
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
      Depth          SfM           SLAM
        │             │             │
        └─────────────┼─────────────┘
                      ▼
                   3D World
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
   Point Cloud       Mesh       Neural Field
        │             │             │
        └─────────────┼─────────────┘
                      ▼
              Scene Understanding
                      │
                      ▼
             Vision-Language Model
                      │
                      ▼
                     LLM
                      │
                      ▼
                  Reasoning
                      │
                      ▼
                    Action

85. Como estudar Computer Vision

Para um desenvolvedor, uma sequência possível seria:

Python
 ↓
NumPy
 ↓
OpenCV
 ↓
Image Processing
 ↓
CNN
 ↓
Classification
 ↓
Object Detection
 ↓
Segmentation
 ↓
Video Processing
 ↓
Tracking
 ↓
Camera Geometry
 ↓
Calibration
 ↓
Stereo
 ↓
Depth
 ↓
Feature Matching
 ↓
SfM
 ↓
MVS
 ↓
Point Clouds
 ↓
Registration
 ↓
SLAM
 ↓
Mesh Reconstruction
 ↓
Vision Transformers
 ↓
Vision-Language Models
 ↓
Multimodal AI
 ↓
Vision + LLM

Não é necessário dominar tudo para começar a construir aplicações. Mas esse mapa ajuda a entender onde cada tecnologia se encaixa.

86. Stack para começar

Um stack prático para estudar e prototipar:

Language
    Python

Numerical Computing
    NumPy

Image Processing
    OpenCV

Deep Learning
    PyTorch

Object Detection
    YOLO / DETR

Segmentation
    SAM / segmentation models

3D
    Open3D

Photogrammetry
    COLMAP

Point Clouds
    Open3D / PCL

Optimization
    SciPy / Ceres

Model Runtime
    ONNX Runtime / TensorRT

Backend
    FastAPI

Mobile
    Swift / Kotlin / React Native

Multimodal
    VLM + LLM

87. O ponto principal

O mais importante para quem desenvolve sistemas de Computer Vision é não enxergar essas tecnologias como ferramentas isoladas.

Um projeto real pode começar com:

Camera

e terminar com:

3D Model
+
Scene Understanding
+
LLM

No meio existem dezenas de etapas:

Capture
 ↓
Preprocessing
 ↓
Detection
 ↓
Segmentation
 ↓
Tracking
 ↓
Calibration
 ↓
Depth
 ↓
Pose Estimation
 ↓
SfM
 ↓
MVS
 ↓
Point Cloud
 ↓
Registration
 ↓
Mesh
 ↓
Vision Model
 ↓
VLM
 ↓
LLM

Cada etapa resolve um problema diferente.

E é justamente a combinação delas que permite construir sistemas realmente sofisticados.

Conclusão

Computer Vision não é apenas reconhecimento de imagens.

É a combinação de várias áreas:

Computer Vision
+
Deep Learning
+
Geometry
+
Computer Graphics
+
3D Reconstruction
+
Robotics
+
Generative AI
+
Multimodal AI
+
LLMs

Uma forma de enxergar a evolução é:

Pixels
  ↓
Features
  ↓
Objects
  ↓
Semantics
  ↓
Motion
  ↓
Depth
  ↓
Geometry
  ↓
3D
  ↓
Scene Understanding
  ↓
Multimodal Reasoning
  ↓
Action

Uma câmera produz pixels.

Um detector encontra objetos.

Um modelo de segmentação separa regiões.

Um sistema geométrico recupera profundidade e pose.

SfM e MVS conseguem reconstruir uma cena.

LiDAR fornece medições espaciais.

SLAM conecta percepção e localização.

Modelos multimodais conectam visão e linguagem.

E um LLM pode usar todas essas informações para raciocinar sobre o que está acontecendo.

É aí que Computer Vision começa a deixar de ser apenas "reconhecimento de imagem" e passa a funcionar como uma camada de percepção de sistemas inteligentes.

Referências e tecnologias para explorar

Computer Vision

OpenCV
PyTorch
scikit-image
MediaPipe

Detection

YOLO
Faster R-CNN
DETR

Segmentation

U-Net
Mask R-CNN
SAM

Geometry

Camera Calibration
Stereo Vision
Epipolar Geometry
SfM
MVS

Photogrammetry

COLMAP
OpenMVG
OpenMVS
Meshroom

3D

Open3D
PCL
SLAM
NeRF
Gaussian Splatting

Modern AI

Vision Transformers
Vision-Language Models
Multimodal LLMs
Visual Embeddings
RAG

Final thought

O caminho mais interessante, na minha visão, não está em escolher entre Computer Vision, 3D ou LLM.

Está em conectar essas áreas.

Perception
    +
Geometry
    +
3D
    +
Deep Learning
    +
Language
    =
Intelligent Systems

Quando essas camadas começam a trabalhar juntas, a aplicação deixa de apenas "ver" e passa a construir uma representação cada vez mais rica do mundo.

Database-per-tenant {Explicando Padrões de arquitetura de banco de dados multilocatários}

Alexandre Justen Filho — Fri, 03 Oct 2025 01:43:45 +0000

Arquiteturas de Banco de Dados para Multi-Tenancy

=================================================

Quando comecei a desenvolver a versão web de um sistema que já rodava localmente, me deparei com uma decisão estratégica: como estruturar o banco de dados para suportar vários clientes (multi-tenancy). Essa escolha não é apenas técnica; ela impacta escalabilidade, segurança, custos e até a forma como a equipe vai trabalhar no dia a dia.

Grosso modo, existem três modelos principais: desde o mais simples, onde todos compartilham as mesmas tabelas, até o mais isolado, com um banco dedicado para cada cliente.

Padrão 1 – Banco Único e Tabelas Compartilhadas

CREATE TABLE customers (
  id INT PRIMARY KEY,
  tenant_id INT NOT NULL,
  name VARCHAR(255),
  email VARCHAR(255),
  INDEX(tenant_id)
);

Nesse modelo, todos os clientes dividem as mesmas tabelas. O que diferencia os dados é uma coluna tenant_id. É o desenho mais direto e geralmente o primeiro que vem à mente.

Vantagens

Mais barato e simples de operar.
Backups, monitoramento e atualizações em um único ponto.
Mudanças de schema refletem em todos os clientes de uma vez.

Desvantagens

Qualquer descuido em queries pode vazar dados entre clientes.
Um cliente pesado pode afetar todos os outros.
Não dá muita flexibilidade de customização.

Padrão 2 – Banco Único, Schemas Separados

CREATE SCHEMA tenant1;
CREATE TABLE tenant1.customers (...);

CREATE SCHEMA tenant2;
CREATE TABLE tenant2.customers (...);

Aqui ainda temos um banco só, mas cada cliente fica em um schema separado. É algo que bancos como PostgreSQL e SQL Server oferecem nativamente.

Vantagens

Mais isolamento do que o modelo anterior.
Possibilita pequenas customizações por cliente.
Custos ainda controlados (um único banco físico).

Desvantagens

As migrações precisam ser replicadas em cada schema.
Com muitos clientes, o banco pode atingir limites de objetos.
Gerenciar backups/restores é mais trabalhoso.

Padrão 3 – Um Banco por Cliente

CREATE DATABASE tenant1;
CREATE DATABASE tenant2;

Esse é o modelo mais isolado: cada cliente tem sua própria base de dados, totalmente separada das demais.

Vantagens

Isolamento total (ideal para compliance e segurança).
Escalabilidade independente por cliente.
Facilidade em atender exigências regulatórias.

Desvantagens

Maior custo de operação e infraestrutura.
Migrações de schema são mais trabalhosas.
Exige automação para gerenciar conexões e atualizações.

Comparativo Rápido

Critério	Compartilhar Banco + Esquema	Compartilhar Banco + Schemas	Banco por Tenant
Suporte em SGDBs	Todos	PostgreSQL, SQL Server, etc.	Todos
Conformidade	Difícil	Possível com esforço extra	Mais simples
Complexidade	Baixa	Média/Alta	Alta
Customização	Limitada	Moderada	Total
Escalabilidade	Banco inteiro	Banco inteiro	Por cliente

Dicas para Migrações de Schema

Não importa o modelo que você escolha, mudar a estrutura do banco será sempre uma dor de cabeça se não houver disciplina.

Versione seus scripts no Git com numeração sequencial.
Automatize com CI/CD, rodando testes antes de aplicar.
Escreva scripts idempotentes (seguros para rodar mais de uma vez).
Aplique mudanças primeiro em staging e depois em subset de clientes.
Mantenha compatibilidade retroativa sempre que possível.
Use um catálogo centralizado para acompanhar versões de cada tenant.

Conclusão

Não existe receita única. O melhor modelo depende do seu estágio e das exigências do seu negócio.

Quer começar simples e barato? → Banco + Tabelas Compartilhadas
Precisa de isolamento e compliance? → Banco por Cliente
Busca um equilíbrio? → Banco único com Schemas separados

O mais importante é escolher algo que funcione bem hoje, mas com clareza de como migrar no futuro conforme sua base de clientes crescer.

Referências

Tianzhou 18 de março de 2025 – Multi-Tenant Database Architecture Patterns Explained
turso – Database Multi-Tenancy Made Easy

GitHub em 1 Clique: De Público para Privado em Segundos!🔒

Alexandre Justen Filho — Sat, 01 Feb 2025 02:26:12 +0000

Você já quis alterar rapidamente um repositório público para privado no GitHub sem precisar navegar pelas configurações? Este script em Node.js permite fazer isso diretamente pelo terminal, em apenas um clique!

Para contextualizar: fui contratado como professor de desenvolvimento de sistemas e, ao montar meus planos de aula, percebi que tinha muitos códigos e algoritmos no meu GitHub que seriam úteis durante as aulas. Como alguns alunos já estão me procurando nas redes sociais, percebi que deveria tornar meus repositórios importantes privados.

Quando comecei essa tarefa, achei que seria fácil, mas depois de 10 repositórios, ainda faltavam 53, kkkkk. Então, achei mais prudente resolver isso com um script simples, e foi isso que fiz.

Primeiro passo: Obter sua API token.

Acesse o link: https://github.com/settings/tokens

Você pode gerar um token, que será muito importante para termos acesso e modificar a visibilidade do repositório.

Você deve marcar a opção "repo".

Pronto! Agora que você tem a chave, vamos ao código:

const axios = require('axios');
const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function ask(query) {
  return new Promise(resolve => rl.question(query, resolve));
}

async function getRepositories(username, token) {
  try {
    const response = await axios.get(`https://api.github.com/users/${username}/repos`, {
      headers: { Authorization: `Bearer ${token}` }
    });

    return response.data.map(repo => repo.name);
  } catch (error) {
    console.error('Erro ao buscar repositórios');
    return [];
  }
}

async function visibility(username, token, repoName) {
  try {
    await axios.patch(`https://api.github.com/repos/${username}/${repoName}`, 
      { private: true }, 
      { headers: { Authorization: `Bearer ${token}` } }
    );
    console.log(`O repositório ${repoName} foi privado`);
  } catch (error) {
    console.error('Erro ao alterar visibilidade');
  }
}

async function main() {
  const username = await ask('Nome de usuário do GitHub: ');
  const token = await ask('Digite sua token: ');

  const repos = await getRepositories(username, token);

  if (repos.length === 0) {
    console.log('Nenhum repositório encontrado');
    rl.close();
    return;
  }

  repos.forEach((repo, index) => console.log(`${index + 1}. ${repo}`));

  const choice = await ask('\nDigite o número do repositório que deseja tornar privado: ');
  const selectedRepo = repos[parseInt(choice) - 1];

  if (selectedRepo) {
    await visibility(username, token, selectedRepo);
  } else {
    console.log('Escolha inválida.');
  }

  rl.close();
}

main();

Resumo do Fluxo do Código
O usuário fornece seu nome de usuário e token do GitHub.
O script faz uma requisição para listar os repositórios do usuário.
O script exibe os repositórios disponíveis e pede ao usuário para escolher um.
O script altera a visibilidade do repositório escolhido, tornando-o privado.
O script exibe uma mensagem de confirmação ou erro dependendo do resultado.
Esse código usa axios para fazer as requisições HTTP e readline para interação com o usuário, criando uma solução simples, mas eficaz, para alterar rapidamente a visibilidade de múltiplos repositórios no GitHub.

Se esse código foi útil para você, deixe um comentário ou curta! Muito obrigado por ler até aqui.

Transforme Seu Servidor Local em um Site Público com Ngrok

Alexandre Justen Filho — Thu, 31 Oct 2024 02:20:43 +0000

Quando desenvolvemos uma aplicação web localmente e queremos compartilhá-la para testes ou demonstrações, encontramos uma barreira comum: a aplicação só está acessível em nossa rede local. É aqui que entra o ngrok!

O Que é Tunelamento?

O tunelamento permite expor um servidor local para a internet através de um canal seguro. Isso é especialmente útil em ambientes de desenvolvimento, onde você deseja compartilhar seu servidor com clientes ou testá-lo em outros dispositivos sem ter que fazer o deploy completo.

Por Que Usar o Ngrok?

O ngrok é uma das ferramentas mais populares para tunelamento, e por boas razões:

Rápido e Fácil de Usar: Com apenas uma linha de comando, você pode criar um túnel para o seu servidor local.
Segurança: Cria uma conexão segura (HTTPS) automaticamente.
Flexível: Funciona com HTTP, HTTPS, TCP e até WebSockets.
Insights e Depuração: Permite monitorar e depurar requisições recebidas em tempo real.

Como Usar o Ngrok?

Baixe e Instale o Ngrok:

Acesse ngrok.com e baixe a versão adequada para o seu sistema.

Após o download, descompacte o arquivo e coloque o executável em uma pasta de fácil acesso.

Autenticação (opcional, mas recomendado):

Crie uma conta no ngrok e copie seu token de autenticação.
No terminal, execute:

ngrok authtoken SEU_TOKEN

Iniciando o Túnel:

Com o servidor da sua aplicação rodando (por exemplo, na porta 3000), inicie o túnel com o comando:

ngrok http 3000

Este comando cria um túnel HTTP e HTTPS para a porta 3000 do seu localhost. Você verá um endereço público no formato https://xxxx.ngrok.io que pode ser acessado de qualquer lugar.

Visualize e Depure o Tráfego:

Acesse http://localhost:4040 para ver informações detalhadas sobre cada requisição recebida, incluindo cabeçalhos, payload e status de resposta. Essa visualização é ótima para depurar APIs.

Encerrando o Túnel:

Para parar o ngrok, basta fechar o terminal ou pressionar Ctrl+C.

Exemplos de Uso do Ngrok

Testes de Webhooks: Ideal para desenvolver e testar webhooks de serviços externos como Stripe, PayPal e GitHub, sem precisar fazer o deploy do código.
Demonstrar Aplicações em Tempo Real: Compartilhe seu progresso com colegas ou clientes em uma aplicação em execução localmente.
Desenvolvimento de APIs: Teste e depure endpoints localmente antes de enviá-los para produção.

O ngrok é uma ferramenta indispensável para quem desenvolve aplicações web e precisa de acesso rápido, seguro e fácil a um servidor local a partir da internet. Com ele, o tunelamento se torna simples, ampliando as possibilidades de desenvolvimento e teste.

🐍Como Importar Dados do Excel para SQLite com Python em Poucas Linhas

Alexandre Justen Filho — Wed, 30 Oct 2024 22:13:11 +0000

Neste post, vou ensinar como transferir dados de uma planilha Excel diretamente para um banco de dados SQLite usando apenas algumas linhas de código em Python. Muito útil para quem precisa centralizar dados em um banco de dados, especialmente para uso em aplicações que fazem consultas frequentes, como dashboards ou ferramentas de análise!

Bibliotecas:

import pandas as pd
import sqlite3

Carregar o Arquivo Excel:

arquivo_excel = './teste.xlsx'
df = pd.read_excel(arquivo_excel)

Conectar ao Banco de Dados SQLite:

conexao = sqlite3.connect('database.db')

Exportar os Dados para o SQLite:

df.to_sql('tabela_excel', conexao, if_exists='replace', index=False)

Fechar a Conexão e Confirmação:

conexao.close()
print("Dados importados com sucesso!")

Dessa forma em poucas linhas de código temos a nossa tabela xlsx exportada para um banco SQLite!

Análise de Sulco de Pneus com Inteligência Artificial em Python!

Alexandre Justen Filho — Wed, 30 Oct 2024 21:16:09 +0000

A análise de sulcos de pneus é uma tarefa crucial para identificar o desgaste e garantir a segurança, especialmente em veículos que percorrem longas distâncias. Com o uso de Inteligência Artificial (IA) e Python, podemos automatizar esse processo de maneira rápida e precisa. Aqui, mostramos como um modelo de rede neural convolucional (CNN), baseado na arquitetura VGG16, classifica pneus em "novos" ou "usados", enquanto o OpenCV ajuda a analisar as imagens para medir a profundidade dos sulcos.

Tecnologias Usadas

Python:
Linguagem de programação popular para IA e Machine Learning, especialmente por suas bibliotecas avançadas.
OpenCV:
Usado para processar as imagens, detectar contornos e medir a área dos sulcos dos pneus.
TensorFlow e Keras:
Bibliotecas de aprendizado profundo. Utilizamos o Keras para trabalhar com o modelo VGG16, uma CNN pré-treinada para reconhecimento de imagens.
Matplotlib:
Biblioteca para visualização de dados e criação de gráficos, tornando os resultados da classificação mais interpretáveis.

Código:

1. Carregar e Pré-processar as Imagens:
As imagens dos pneus são carregadas e redimensionadas para um formato padrão (150x150 pixels) necessário para a entrada do modelo. Esse redimensionamento mantém a proporção e normaliza os valores dos pixels entre 0 e 1 para facilitar o processamento pelo modelo.

import cv2
import numpy as np
from tensorflow.keras.applications.vgg16 import preprocess_input

def process_image(image_path, target_size=(150, 150)):
    image = cv2.imread(image_path)
    if image is None:
        print(f"Erro ao carregar a imagem: {image_path}. Verifique o caminho e a integridade do arquivo.")
        return None, None

    image_resized = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)
    image_array = np.array(image_resized) / 255.0  
    image_array = np.expand_dims(image_array, axis=0)
    image_preprocessed = preprocess_input(image_array)

    return image_resized, image_preprocessed

2. Classificação com o Modelo Treinado:
Carregamos um modelo de rede neural convolucional pré-treinado, que foi ajustado para classificar pneus como "novos" ou "usados". Esse modelo fornece uma pontuação de confiança que indica a probabilidade de um pneu ser novo.

from tensorflow.keras.models import load_model

model = load_model('pneu_classificador.keras')
prediction = model.predict(image_preprocessed)

3. Análise dos Contornos para Profundidade de Sulco:
A detecção da profundidade do sulco é realizada com técnicas de visão computacional. A imagem em escala de cinza passa por um filtro de borrão e pela detecção de bordas com Canny, o que ajuda a identificar contornos dos sulcos. Em seguida, calculamos a área total dos contornos, o que nos permite estimar o desgaste.

def detect_tread_depth(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 30, 100)
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    total_area = sum(cv2.contourArea(c) for c in contours if cv2.contourArea(c) > 100)
    return total_area

4. Visualização e Análise de Resultados:
Após a classificação e análise de cada pneu, os resultados são exibidos com Matplotlib. Comparamos a pontuação de confiança da classificação e a área dos sulcos detectada em cada imagem.

import matplotlib.pyplot as plt

confidence_scores = []
total_area_green_values = []
predicted_classes = []

for image_file in os.listdir(ver_dir):
    image_path = os.path.join(ver_dir, image_file)
    image_resized, image_preprocessed = process_image(image_path)
    if image_preprocessed is not None:
        prediction = model.predict(image_preprocessed)
        confidence_score = prediction[0][0]
        total_area_green = detect_tread_depth(image_resized)

        predicted_class = "novo" if total_area_green > 500 else "usado"
        confidence_scores.append(confidence_score)
        total_area_green_values.append(total_area_green)
        predicted_classes.append(predicted_class)

        plt.imshow(cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB))
        plt.title(f"Pneu {predicted_class} (Área: {total_area_green:.2f}, Confiança: {confidence_score:.2f})")
        plt.axis('off')
        plt.show()

fig, axs = plt.subplots(2, 1, figsize=(10, 10))

axs[0].bar(os.listdir(ver_dir), confidence_scores, color='skyblue')
axs[0].set_title('Confiança na Classificação')
axs[0].set_ylim(0, 1)
axs[0].tick_params(axis='x', rotation=45)

axs[1].bar(os.listdir(ver_dir), total_area_green_values, color='lightgreen')
axs[1].set_title('Área Verde Detectada')
axs[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

Esse meu projeto demonstra como é possível automatizar a análise do desgaste de pneus utilizando IA e visão computacional, resultando em uma classificação precisa e rápida. A arquitetura VGG16 e o uso de OpenCV são fundamentais para combinar a precisão do modelo de rede neural com a análise visual dos sulcos. Esse sistema pode ser expandido para monitoramento contínuo em frotas de veículos, ajudando a reduzir acidentes e otimizar o gerenciamento de pneus.