Skip to content

sbrunomello/zeno

BranchesTags

Repository files navigation

ZENO‑PSI Vision

Java 21 • Gradle • OpenCV (bytedeco) • YOLOv3/YOLOv3‑Tiny • Face (Res10SSD + ArcFace)
Pipeline cognitivo PSI (7 camadas × 21 subcamadas) · UI ao vivo · Execução multi‑threads

Sumário

Visão geral

Este projeto é uma prova de conceito (PoC) completa de percepção visual e cognição simbólica para robôs sociais (ou desktop) em Java 21. Ele integra:

  • Captura de vídeo com OpenCV (VideoCapture)
  • Detecção de objetos via YOLOv3 e YOLOv3‑Tiny
  • Detecção de faces com Res10 SSD (Caffe)
  • Reconhecimento de faces com ArcFace (ONNX) e base local de embeddings
  • UI em tempo real: janela com vídeo, bounding boxes, rótulos e FPS; dashboard web com stream MJPEG e HUD de status/eventos
  • PSI: pipeline cognitivo com 7 camadas, cada uma com 3 subcamadas (input → core → output) ⇒ 21 subcamadas

O foco é ser didático, modular e performático, mantendo configuração centralizada, processamento concorrente e documentação clara.

Arquitetura de software

Camera → [Frame atual] ────────────────────→ UI Renderer → Janela
             │                                     ▲
             │                                     │ Overlays (YOLO/Face/Labels/FPS)
             ├─ YOLO Detector (thread) ────────────┤
             └─ Face + ArcFace (thread) ───────────┘
                          │
                          └─ Eventos → PSI (Perception→…→Reflection)

Módulos principais

  • camera/ — captura de vídeo e screenshots.
  • dnn/ — detecção (YOLO), faces (Res10 SSD) e reconhecimento (ArcFace).
  • overlay/ — composição de bounding boxes e labels.
  • psi/ — pipeline cognitivo (7 camadas × 3 subcamadas).
  • util/ — configuração, métricas de FPS.
  • Main — orquestração (UI + ciclo principal).

Concorrência e backpressure

  • AtomicReference<Mat> guarda o frame atual (baixa latência).
  • Threads dedicadas para YOLO e Faces/ArcFace, com skip de frames configurável.
  • Resultados em DetectionResult com listas sincronizadas.
  • PSI consome eventos simbólicos via BlockingQueue (capacidade limitada).

PSI — Teoria e implementação (7 × 3 = 21)

Cada camada executa input → core → output (3 subcamadas). Os métodos estão em psi/Layers.java e psi/PSIEngine.java.

  1. Perception

    • input: recebe símbolos brutos (detecções, sensores).
    • core: normaliza/valida, agrega metadados (tempo, confiança).
    • output: publica símbolos perceptuais consistentes.

  2. Understanding

    • input: consome símbolos de percepção.
    • core: mapeia para conceitos (ex.: object:person → concept:human; face:* → concept:face).
    • output: hipóteses semânticas de maior nível.

  3. Value Appraisal

    • input: conceitos/hipóteses.
    • core: aplica valência (heurísticas de prioridade/segurança/social).
    • output: valued:* com valência em [-1, +1].

  4. Self‑State

    • input: símbolos valorizados + estado atual.
    • core: atualiza estado interno (foco, energia simbólica, memória breve).
    • output: contexto atualizado.

  5. Planning & Coherence

    • input: contexto + valências.
    • core: seleciona plano (regras simples na PoC; prioridade dinâmica).
    • output: plan:* (ação pretendida).

  6. Action & Expression

    • input: plano.
    • core: escolhe primitiva de ação/expressão (na PoC: logs/intenções; em robô real: atuadores).
    • output: action:* (executável).

  7. Reflection & Adjustment

    • input: resultado da ação + feedback sensorial.
    • core: ajusta preferências/valências; registra memória episódica leve.
    • output: reflected:* (marca para aprendizado incremental).

A implementação é explicável e pronta para evoluir com memória de trabalho, grafo semântico e reforço de valências.

Instalação

Requisitos

  • Java 21 (JDK x64)
  • Gradle (ou usar gradlew)
  • Webcam funcional

Dependências (Gradle) sugeridas

dependencies {
    implementation 'org.bytedeco:opencv-platform:4.11.0-1.5.12'
    implementation 'org.slf4j:slf4j-simple:2.0.13'
    implementation 'org.json:json:20240303'
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
}

Modelos esperados

Coloque estes arquivos em ./models (não versionados):

arcface.onnx
deploy.prototxt
res10_300x300_ssd_iter_140000.caffemodel
yolov3.cfg
yolov3.weights
yolov3-tiny.cfg
yolov3-tiny.weights

A lista COCO de classes do YOLO está em src/main/resources/coco.names.

Execução e atalhos

Na raiz do projeto:

gradle run
# ou, com wrapper:
./gradlew run   # Linux/macOS
.\gradlew run   # Windows

Ao iniciar, abre a janela ZENO‑PSI Vision renderizando a câmera e sobreposições.

Atalhos

  • Q — sair
  • S — screenshot em data/frames/
  • N — cadastrar maior face visível (pede nome; salva em data/face_db.json)

Configuração

Arquivo: src/main/resources/config.properties (exemplo de valores úteis)

# Câmera
camera.index=0
camera.width=1280
camera.height=720

# YOLO
yolo.enabled=true
yolo.useTiny=true
yolo.inputSize=416          # 320/416/608
yolo.confThreshold=0.35
yolo.nmsThreshold=0.40
yolo.cfg=models/yolov3.cfg
yolo.weights=models/yolov3.weights
yolo.tinyCfg=models/yolov3-tiny.cfg
yolo.tinyWeights=models/yolov3-tiny.weights
yolo.names=src/main/resources/coco.names

# Faces
face.enabled=true
face.prototxt=models/deploy.prototxt
face.caffemodel=models/res10_300x300_ssd_iter_140000.caffemodel
face.confThreshold=0.50

# ArcFace
arcface.enabled=true
arcface.onnx=models/arcface.onnx
arcface.similarityThreshold=0.42
arcface.minFaceSize=60

# Frequência (backpressure)
processing.skipFramesYolo=2
processing.skipFramesFace=1

# UI
output.windowTitle=ZENO-PSI Vision
output.drawFps=true
output.drawYolo=true
output.drawFaces=true

# Dados
data.faceDb=data/face_db.json

Dicas

  • Janela preta? Troque camera.index (0→1→2…).
  • FPS baixo? yolo.useTiny=true, yolo.inputSize=320, processing.skipFramesYolo=3, baixar resolução da câmera (ex.: 640×480).

Fluxos de funcionamento

Detecção de objetos (YOLOv3/YOLOv3‑Tiny)

  • Pré‑processamento: blobFromImage com size configurado (320/416/608).
  • Forward nas camadas de saída (getUnconnectedOutLayersNames).
  • Conversão para caixas (x, y, w, h), NMS e rótulos COCO.
  • Publica eventos PSI: Event.perception("object:"+label, conf, x, y, w, h).
  • Apenas as classes person, cell phone, knife e book são desenhadas, cada uma com cor específica para facilitar a identificação visual.

Detecção e reconhecimento de faces

  • Res10 SSD fornece caixas de rosto com confiança.
  • ArcFace gera embedding 512‑D L2‑normalizado (112×112 RGB).
  • Todas as faces acima do tamanho mínimo são reconhecidas; as conhecidas são desenhadas em verde com o nome, enquanto faces desconhecidas aparecem em vermelho.
  • Cadastro com N: salva vetor em data/face_db.json com o nome escolhido.

UI/Render

  • Loop principal compõe overlays (YOLO/Faces/Labels/FPS) e exibe janela.
  • Screenshots com S (útil para debug/relatos).

PSI Pipeline

  • Consome eventos simbólicos (objetos/rostos) e percorre as 7 camadas.
  • Na PoC, o planejamento diferencia humano (approach) de outros (observe).
  • A reflexão ajusta lentamente uma “energia simbólica” (marcador de custo).

Boas práticas de engenharia aplicadas

  • Separação de responsabilidades: captura, visão, UI e cognição isolados.
  • Concorrência segura: AtomicReference, listas sincronizadas, filas limitadas.
  • Backpressure: pular frames para manter fluidez e controlar memória.
  • Config centralizada: evita “números mágicos” em código.
  • Reuso de buffers: reduzir clone()/alocações; liberar Mat após uso.
  • Observabilidade: overlay de FPS; logs mínimos nos pontos críticos.
  • Explicabilidade: PSI com estágios nomeados e símbolos legíveis.

Performance e memória

Perfil low‑mem (recomendado para máquinas modestas)

src/main/resources/config.properties

camera.width=640
camera.height=480
yolo.useTiny=true
yolo.inputSize=320
yolo.confThreshold=0.40
yolo.nmsThreshold=0.45
processing.skipFramesYolo=3
processing.skipFramesFace=2
arcface.enabled=true       # (se pesar, coloque false temporariamente)

build.gradle

tasks.run {
    jvmArgs += ['-Xms256m', '-Xmx1024m']
    jvmArgs += ['-Djava.library.path=']
}

Outras alavancas:

  • Reduzir resolução da câmera (até 424×240 para teste bruto).
  • Aumentar skipFrames e/ou usar yolo.inputSize=256.
  • Desligar overlay de FPS (output.drawFps=false) em cenários extremos.

Teste rápido (checklist)

  1. Janela abre e mostra a câmera.
  2. YOLO: mostre garrafa/celular → aparece bbox com rótulo.
  3. Faces: your face → bbox “face”.
  4. Reconhecimento: N para cadastrar; ao reiniciar/rodar, rótulo muda para seu nome.
  5. Screenshots: S cria PNGs em data/frames/.

Debug API headless

Para iniciar o servidor HTTP leve e acessar o dashboard, execute:

./gradlew run --args="--api.port=8080"

Endpoints principais:

  • GET /health
  • GET /state
  • GET /metrics
  • GET /snapshot.jpg
  • GET /stream.mjpeg?w=&fps=&q=
  • GET /events.ndjson

O dashboard estático fica em /dashboard. O vídeo exibido é capturado via CameraManager e possui overlays de detecções de objetos (YOLO) e faces em tempo real. O painel também mostra FPS, uso de CPU/RAM, quantidade de tracks e o último evento de cada camada PSI, além da lista textual do que o robô está vendo.

Solução de problemas

  • Dependência OpenCV não encontrada: use org.bytedeco:opencv-platform:4.11.0-1.5.12 e gradle --refresh-dependencies clean run.
  • Janela preta: ajuste camera.index, feche apps que usam a webcam, reduza resolução.
  • Consumo alto de CPU/RAM: habilite perfil low‑mem, use YOLO‑Tiny, aumente skipFrames.
  • Faces não reconhecidas: verifique iluminação/frontalidade; ajuste arcface.minFaceSize e arcface.similarityThreshold (0.38–0.50).
  • Atrasos na UI: evite logs por frame; mantenha a UI thread leve.

Roadmap

  • Memória episódica (serialização leve de eventos PSI).
  • Grafo semântico (entendimento mais rico).
  • Valências adaptativas (reforço supervisionado pelo feedback).
  • Áudio (ASR/TTS) como canal sensório‑motor adicional.
  • Aceleração (OpenVINO/CUDA) quando disponível.
  • Integração robótica (motores/LED/voz) na Action & Expression.

Segurança e privacidade

  • Tudo roda localmente; nenhuma imagem é enviada à rede.
  • Embeddings de faces residem em data/face_db.json.
  • Remova identidades apagando entradas do JSON ou o arquivo.
  • Consentimento é essencial ao operar em ambientes com outras pessoas.

Licença

MIT — uso livre, sem garantias. Veja LICENSE.

Créditos

  • OpenCV (bytedeco presets)
  • YOLOv3 / COCO classes
  • Res10 SSD Face Detector
  • ArcFace (modelo ONNX)

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages