# IA Não é Só Chat: o Mundo de Computer Vision, 3D e IA Multimodal > Source: > Published: 2026-08-30 05:25:31+00:00 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. 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. 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. Antes de colocar uma imagem em uma rede neural, muitas vezes é necessário prepará-la. Algumas operações comuns: 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. 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: Classification é normalmente o ponto de entrada para quem começa a estudar visão computacional com Deep Learning. 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 ``` 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 │ │ │ └────────┘ │ │ │ └──────────────────────────────┘ ``` Exemplos: ``` R-CNN Fast R-CNN Faster R-CNN Mask R-CNN ``` A ideia geral: ``` Image ↓ Region Proposals ↓ Classification ↓ Bounding Box Refinement ``` Exemplos: ``` YOLO SSD RetinaNet ``` A ideia: ``` Image ↓ Neural Network ↓ Boxes + Classes + Confidence ``` Essa abordagem costuma ser muito interessante quando existe requisito de tempo real. Um exemplo conhecido é o DETR. Aqui a detecção é formulada de uma maneira diferente, usando a arquitetura Transformer para prever os objetos. 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 ``` Detection trabalha com bounding boxes. Segmentation trabalha em nível de pixel. Cada pixel recebe uma classe: ``` pixel → class ``` Por exemplo: ``` road car person sky building ``` Aqui cada objeto é uma instância separada: ``` person #1 person #2 person #3 ``` Mesmo todos pertencendo à classe `person` . Combina semantic segmentation e instance segmentation para representar a cena de forma mais completa. 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. 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: ``` bash Imagem de documento ↓ "NOTA FISCAL" "VALOR: R$ 1.250,00" "CNPJ: ..." ``` OCR moderno pode combinar CNNs, LSTMs, Transformers e modelos multimodais. 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. 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 ``` 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. 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 ``` 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: 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 ``` Depois de detectar e acompanhar objetos, podemos analisar: Um pipeline: ``` Video ↓ Detection ↓ Tracking ↓ Trajectory ↓ Motion Analysis ↓ Event Detection ``` É uma base para aplicações como monitoramento, análise esportiva e robótica. 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. Calibration determina os parâmetros da câmera. 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. 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 ``` 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. 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. Depth estimation tenta produzir um mapa de profundidade. Entrada: ``` RGB Image ``` Saída: ``` Depth Map ``` Pode ser: Representação: ``` RGB ↓ Depth Network ↓ Depth Map ``` Modelos modernos utilizam arquiteturas profundas, inclusive Transformers. 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. 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. 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. 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. 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. 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) ``` 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. 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 ``` 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 ``` 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) ``` 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) ``` 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. 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. SLAM significa: Simultaneous Localization and Mapping O sistema precisa resolver duas coisas ao mesmo tempo: ``` Onde estou? ``` e: ``` Como é o ambiente? ``` Pipeline simplificado: ``` Sensor ↓ Feature / Point Extraction ↓ Motion Estimation ↓ Pose ↓ Map Update ↓ Loop Closure ``` Aplicações: 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. 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. 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 ``` 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. 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. 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 ``` 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. 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: Face Detection responde: Onde existem rostos? Normalmente produz bounding boxes. ``` Image ↓ Face Detector ↓ Bounding Boxes ``` Isso é diferente de reconhecimento facial. 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. 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: 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 ``` 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. 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. | 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. 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. 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. 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. Embeddings são uma das peças importantes dos sistemas modernos. ``` Image ↓ Encoder ↓ Vector ``` Depois podemos usar o vetor para: Um exemplo: ``` Query Image ↓ Embedding ↓ Vector Database ↓ Similar Content ↓ LLM / Application ``` 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. 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. 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. 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 ``` 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. 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. 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. 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. 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. Computer Vision moderno pode ser bastante pesado. CPU é muito útil para: GPU é especialmente boa para: Um pipeline pode ser: ``` CPU ↓ Data Preparation ↓ GPU ↓ Inference ↓ CPU ↓ Post-processing ``` Um stack bastante comum: ``` Python NumPy OpenCV PyTorch scikit-image OpenCV MediaPipe Open3D PCL COLMAP OpenMVG OpenMVS Meshroom Open3D PyTorch TensorFlow ONNX TensorRT ARKit Vision Core ML TensorFlow Lite ONNX Runtime ``` 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. 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 ``` 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 ``` Um modelo não deve ser avaliado apenas olhando alguns resultados. É necessário usar métricas. ``` Accuracy Precision Recall F1 Top-k Accuracy IoU Precision Recall mAP IoU Dice Pixel Accuracy MOTA MOTP IDF1 HOTA ``` 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 ``` 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. 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. 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. 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. 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 ``` 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. 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. 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. 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. 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. 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 ``` 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 ``` 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. 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 ``` 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. 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. ``` OpenCV PyTorch scikit-image MediaPipe YOLO Faster R-CNN DETR U-Net Mask R-CNN SAM Camera Calibration Stereo Vision Epipolar Geometry SfM MVS COLMAP OpenMVG OpenMVS Meshroom Open3D PCL SLAM NeRF Gaussian Splatting Vision Transformers Vision-Language Models Multimodal LLMs Visual Embeddings RAG ``` 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.