Merge branch 'clipper/expressions' into clipper/integ
This commit is contained in:
+65
-8
@@ -167,16 +167,32 @@ class YuNetDetector:
|
|||||||
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
|
return [(float(f[0]), float(f[1]), float(f[2]), float(f[3]), float(f[14])) for f in faces]
|
||||||
|
|
||||||
|
|
||||||
|
def pose_from_matrix(m: Any) -> tuple[float, float, float]:
|
||||||
|
"""(yaw, pitch, roll) em graus da matriz 4×4 de transformação facial do MediaPipe (linhas × colunas).
|
||||||
|
|
||||||
|
Conferido em quadros reais (sessão 8): pitch DIMINUI quando a cabeça vai para trás (bebendo de lata: −25° contra
|
||||||
|
~+12° do normal, que olha um pouco para baixo); yaw ±50° = rosto virado de lado; roll ±45° = cabeça deitada.
|
||||||
|
"""
|
||||||
|
pitch = math.degrees(math.atan2(float(m[2][1]), float(m[2][2])))
|
||||||
|
yaw = math.degrees(math.atan2(-float(m[2][0]), math.hypot(float(m[2][1]), float(m[2][2]))))
|
||||||
|
roll = math.degrees(math.atan2(float(m[1][0]), float(m[0][0])))
|
||||||
|
return yaw, pitch, roll
|
||||||
|
|
||||||
|
|
||||||
class MediaPipeTracker:
|
class MediaPipeTracker:
|
||||||
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes. Um por bloco.
|
"""MediaPipe Face Landmarker em modo VIDEO: 478 pontos + 52 blendshapes + matriz de pose. Um por bloco.
|
||||||
|
|
||||||
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
|
API do mediapipe 1.2.3 (bancada): `from mediapipe.tasks import python` NÃO existe nesta versão — importar os
|
||||||
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
|
submódulos. Timestamps têm de crescer sempre dentro do mesmo landmarker.
|
||||||
|
|
||||||
|
`detector` (YuNet, opcional): quando o MediaPipe não acha o rosto — streamer de perfil olhando o monitor do lado
|
||||||
|
(sessão 15, tfue: rosto em só 10 % dos quadros, YuNet em 100 %) —, a caixa da cabeça vira `FaceSample(head=True)`:
|
||||||
|
sem expressão, mas com posição e tamanho para o corpo (agitação, chegar perto, sair do quadro).
|
||||||
"""
|
"""
|
||||||
|
|
||||||
name = "mediapipe"
|
name = "mediapipe"
|
||||||
|
|
||||||
def __init__(self, model_path: Path):
|
def __init__(self, model_path: Path, detector: Detector | None = None):
|
||||||
try:
|
try:
|
||||||
import mediapipe as mp
|
import mediapipe as mp
|
||||||
import numpy as np
|
import numpy as np
|
||||||
@@ -193,8 +209,10 @@ class MediaPipeTracker:
|
|||||||
min_face_presence_confidence=0.5,
|
min_face_presence_confidence=0.5,
|
||||||
min_tracking_confidence=0.5,
|
min_tracking_confidence=0.5,
|
||||||
output_face_blendshapes=True,
|
output_face_blendshapes=True,
|
||||||
|
output_facial_transformation_matrixes=True, # pose da cabeça (balanço, aceno, cabeça para trás)
|
||||||
)
|
)
|
||||||
self._lm = vision.FaceLandmarker.create_from_options(options)
|
self._lm = vision.FaceLandmarker.create_from_options(options)
|
||||||
|
self._detector = detector
|
||||||
self._last_ms = -1
|
self._last_ms = -1
|
||||||
|
|
||||||
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
|
def process(self, t: float, rgb: Any) -> reaction.FaceSample:
|
||||||
@@ -203,11 +221,30 @@ class MediaPipeTracker:
|
|||||||
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
|
image = self._mp.Image(image_format=self._mp.ImageFormat.SRGB, data=self._np.ascontiguousarray(rgb))
|
||||||
result = self._lm.detect_for_video(image, ms)
|
result = self._lm.detect_for_video(image, ms)
|
||||||
if not result.face_landmarks:
|
if not result.face_landmarks:
|
||||||
return reaction.FaceSample(t, False)
|
return self._head_only(t, rgb)
|
||||||
xs = [p.x for p in result.face_landmarks[0]]
|
xs = [p.x for p in result.face_landmarks[0]]
|
||||||
ys = [p.y for p in result.face_landmarks[0]]
|
ys = [p.y for p in result.face_landmarks[0]]
|
||||||
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
|
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]} if result.face_blendshapes else {}
|
||||||
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend)
|
matrixes = getattr(result, "facial_transformation_matrixes", None)
|
||||||
|
pose = pose_from_matrix(matrixes[0]) if matrixes else None
|
||||||
|
return reaction.FaceSample(t, True, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, max(ys) - min(ys), blend,
|
||||||
|
pose)
|
||||||
|
|
||||||
|
def _head_only(self, t: float, rgb: Any) -> reaction.FaceSample:
|
||||||
|
"""Sem rosto no MediaPipe: a caixa do YuNet (se houver) diz onde está a cabeça. Falha do detector não derruba
|
||||||
|
o bloco: o quadro fica só sem rosto, como antes."""
|
||||||
|
if self._detector is None:
|
||||||
|
return reaction.FaceSample(t, False)
|
||||||
|
try:
|
||||||
|
detections = self._detector.detect(self._np.ascontiguousarray(rgb[:, :, ::-1])) # YuNet quer BGR
|
||||||
|
except Exception as exc: # noqa: BLE001 - OpenCV pode falhar num quadro; o rastreio do rosto segue
|
||||||
|
log.debug("YuNet falhou no quadro %.2f: %s", t, exc)
|
||||||
|
return reaction.FaceSample(t, False)
|
||||||
|
if not detections:
|
||||||
|
return reaction.FaceSample(t, False)
|
||||||
|
x, y, w, h, _score = max(detections, key=lambda d: d[4])
|
||||||
|
height, width = rgb.shape[:2]
|
||||||
|
return reaction.FaceSample(t, False, (x + w / 2) / width, (y + h / 2) / height, h / height, head=True)
|
||||||
|
|
||||||
def close(self) -> None:
|
def close(self) -> None:
|
||||||
self._lm.close()
|
self._lm.close()
|
||||||
@@ -483,6 +520,8 @@ def to_frame(seconds: list[reaction.FaceSecond], crop: dict) -> list[reaction.Fa
|
|||||||
s.cy = crop["y"] + s.cy * crop["h"]
|
s.cy = crop["y"] + s.cy * crop["h"]
|
||||||
if s.size is not None:
|
if s.size is not None:
|
||||||
s.size = s.size * crop["h"]
|
s.size = s.size * crop["h"]
|
||||||
|
if s.hsize is not None:
|
||||||
|
s.hsize = s.hsize * crop["h"]
|
||||||
return seconds
|
return seconds
|
||||||
|
|
||||||
|
|
||||||
@@ -538,7 +577,7 @@ class FaceService:
|
|||||||
if backend == OpenSeeFaceTracker.name:
|
if backend == OpenSeeFaceTracker.name:
|
||||||
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
|
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
|
||||||
try:
|
try:
|
||||||
return MediaPipeTracker(self.store.path("face_landmarker"))
|
return MediaPipeTracker(self.store.path("face_landmarker"), self._head_detector())
|
||||||
except FaceUnavailable as first:
|
except FaceUnavailable as first:
|
||||||
if backend == MediaPipeTracker.name:
|
if backend == MediaPipeTracker.name:
|
||||||
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
|
raise # sessão começou no MediaPipe: espera ele voltar em vez de trocar no meio
|
||||||
@@ -547,6 +586,15 @@ class FaceService:
|
|||||||
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
|
except Exception as exc: # noqa: BLE001 - erro do próprio MediaPipe ao carregar o modelo
|
||||||
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
|
raise FaceUnavailable(f"MediaPipe não carregou: {exc}") from exc
|
||||||
|
|
||||||
|
def _head_detector(self) -> Detector | None:
|
||||||
|
"""YuNet para a cabeça quando o MediaPipe perde o rosto; sem ele o rastreio segue como antes (só sem corpo de
|
||||||
|
perfil)."""
|
||||||
|
try:
|
||||||
|
return self._detector_factory()
|
||||||
|
except FaceUnavailable as exc:
|
||||||
|
log.info("rastreio sem a caixa da cabeça (YuNet indisponível: %s)", exc)
|
||||||
|
return None
|
||||||
|
|
||||||
def session_backend(self, session_id: int) -> str | None:
|
def session_backend(self, session_id: int) -> str | None:
|
||||||
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
|
"""Backend que a série da sessão já usa (None = nenhum bloco rastreado ainda)."""
|
||||||
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
|
row = self.e.db.get("SELECT data_json FROM face_track WHERE session_id = ? AND status = 'done' ORDER BY idx LIMIT 1",
|
||||||
@@ -680,7 +728,7 @@ class FaceService:
|
|||||||
self._save(sid, idx, "error", {"cam": cam}, msg)
|
self._save(sid, idx, "error", {"cam": cam}, msg)
|
||||||
return "error"
|
return "error"
|
||||||
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
|
# Segundos inteiros cujo início cai no bloco: [ceil(início), ceil(fim)) — blocos vizinhos não se repetem.
|
||||||
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first), crop)
|
seconds = to_frame(reaction.per_second(samples, last - first, start_s=first, params=self.params), crop)
|
||||||
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
|
data = {"cam": cam, "crop": crop, "fps": FPS, "backend": tracker.name, "frames": len(samples),
|
||||||
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
|
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
|
||||||
"seconds": reaction.seconds_to_json(seconds)}
|
"seconds": reaction.seconds_to_json(seconds)}
|
||||||
@@ -779,7 +827,8 @@ class FaceService:
|
|||||||
return ""
|
return ""
|
||||||
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
|
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), hi)
|
||||||
inside = [s for s in seconds if lo <= s.t <= hi]
|
inside = [s for s in seconds if lo <= s.t <= hi]
|
||||||
if not inside or not any(s.smile is not None for s in inside):
|
# Só a cabeça (de perfil, sem expressão) também rende linha: o corpo diz alguma coisa ao analista.
|
||||||
|
if not inside or not any(s.smile is not None or (s.head or 0.0) > 0 for s in inside):
|
||||||
return ""
|
return ""
|
||||||
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
|
return reaction.summarize(seconds, lo, hi, self.params, relative=False)
|
||||||
|
|
||||||
@@ -792,16 +841,23 @@ class FaceService:
|
|||||||
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
|
seconds = self.dense(sid, max(0.0, start - BASELINE_EXTRA_S), end)
|
||||||
signal = reaction.reaction_signal(seconds, params=self.params)
|
signal = reaction.reaction_signal(seconds, params=self.params)
|
||||||
moments = reaction.reaction_moments(seconds, self.params)
|
moments = reaction.reaction_moments(seconds, self.params)
|
||||||
|
body = reaction.body_moments(seconds, self.params)
|
||||||
|
expressions = reaction.expression_map(seconds, self.params, body)
|
||||||
counts = {r["status"]: r["n"] for r in self.e.db.all(
|
counts = {r["status"]: r["n"] for r in self.e.db.all(
|
||||||
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
|
"SELECT status, COUNT(*) AS n FROM face_track WHERE session_id = ? GROUP BY status", sid)}
|
||||||
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
|
total = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND deleted = 0", sid)["n"]
|
||||||
rows = []
|
rows = []
|
||||||
for s, z in zip(seconds, signal):
|
for s, z, mapped in zip(seconds, signal, expressions):
|
||||||
if s.t < start:
|
if s.t < start:
|
||||||
continue
|
continue
|
||||||
item = s.to_json()
|
item = s.to_json()
|
||||||
if z is not None:
|
if z is not None:
|
||||||
item["signal"] = round(z, 2)
|
item["signal"] = round(z, 2)
|
||||||
|
# Mapa de expressões: a expressão dominante e o movimento do corpo no segundo (ausentes = nada).
|
||||||
|
if mapped["expr"]:
|
||||||
|
item["expr"] = mapped["expr"]
|
||||||
|
if mapped["body"]:
|
||||||
|
item["body"] = mapped["body"]
|
||||||
rows.append(item)
|
rows.append(item)
|
||||||
return {
|
return {
|
||||||
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
|
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
|
||||||
@@ -812,6 +868,7 @@ class FaceService:
|
|||||||
"fromS": start, "toS": end,
|
"fromS": start, "toS": end,
|
||||||
"seconds": rows,
|
"seconds": rows,
|
||||||
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
|
"moments": [m.to_json() for m in moments if start <= m.peak_s <= end],
|
||||||
|
"body": [b.to_json() for b in body if b.end_s >= start and b.start_s <= end],
|
||||||
}
|
}
|
||||||
|
|
||||||
# ---------- câmera local (YuNet + reaction.locate_cam)
|
# ---------- câmera local (YuNet + reaction.locate_cam)
|
||||||
|
|||||||
+486
-25
@@ -7,7 +7,10 @@ rosto do YuNet) e transforma em:
|
|||||||
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela
|
- um sinal de reação por segundo **relativo ao neutro do próprio streamer** (z robusto: mediana + MAD da janela
|
||||||
recente, só com segundos em que o rosto aparece). Tem streamer que fica sorrindo o tempo todo, tem quem fale
|
recente, só com segundos em que o rosto aparece). Tem streamer que fica sorrindo o tempo todo, tem quem fale
|
||||||
de boca aberta: o que importa é o desvio do normal DELE, não o valor absoluto do blendshape;
|
de boca aberta: o que importa é o desvio do normal DELE, não o valor absoluto do blendshape;
|
||||||
- picos rotulados (risada, grito, susto, choque, confuso, raiva) com o início da reação, e um texto curto para o juiz;
|
- picos rotulados (risada, grito, susto, choque, confuso, raiva e, desde 18/11/2026, gargalhada, medo, espanto,
|
||||||
|
nojo, tristeza, tenso; bocejo não é reação) com o início da reação, e um texto curto para o juiz;
|
||||||
|
- o corpo/cabeça mesmo sem expressão (balançando, acenando, agitado, chegou perto, saiu do quadro) e o mapa de
|
||||||
|
expressões por segundo (doc/clipador/EXPRESSOES.md);
|
||||||
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados.
|
- a posição da câmera no quadro (`locate_cam`) a partir das detecções de alguns quadros espalhados.
|
||||||
|
|
||||||
Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
|
Sem rosto no segundo → sinal `None`, e `None` nunca vira pico.
|
||||||
@@ -28,6 +31,35 @@ EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "br
|
|||||||
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s)
|
BASELINE_STEP_S = 5 # o neutro do streamer é recalculado a cada 5 s (anda devagar; a janela já ignora os últimos 10 s)
|
||||||
SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
|
SECOND_FIELDS: tuple[str, ...] = ("cx", "cy", "size", "smile", "jaw", "surprise", "frown", "brow", "blink", "motion")
|
||||||
|
|
||||||
|
# --- Mapa de expressões (18/11/2026, doc/clipador/EXPRESSOES.md). Tudo OPCIONAL na série: o que foi gravado antes
|
||||||
|
# não tem estes campos e continua valendo (canal ausente = parado, nunca vira pico).
|
||||||
|
# Expressões a mais dos 52 blendshapes (máximo do segundo). `noseSneer*` e `cheekSquint*` saem ~0 SEMPRE no modelo do
|
||||||
|
# MediaPipe (medido em 4 sessões): nojo e raiva não podem depender deles — o lábio de cima (`upper_lip`) faz o papel.
|
||||||
|
EXTRA_EXPRESSION_CHANNELS: tuple[str, ...] = (
|
||||||
|
"brow_inner", # browInnerUp sozinho (medo/tristeza; `brow` junta a interna e a externa)
|
||||||
|
"mouth_frown", # cantos da boca para baixo (tristeza)
|
||||||
|
"squint", # olhos semicerrados (raiva/tensão)
|
||||||
|
"press", # lábios apertados (tensão/raiva)
|
||||||
|
"stretch", # boca esticada para os lados (medo, careta)
|
||||||
|
"upper_lip", # lábio de cima levantado (nojo; sobe junto na gargalhada)
|
||||||
|
"pucker", # boca em "O" (bico ou funil: espanto, "uuuh")
|
||||||
|
)
|
||||||
|
POSE_FIELDS: tuple[str, ...] = ("yaw", "pitch", "roll") # graus, média do segundo (matriz de transformação facial)
|
||||||
|
# Corpo/cabeça: `shake`/`nod` = idas e voltas da cabeça (yaw/pitch) na janela de 2 s que começa 0,5 s antes do segundo;
|
||||||
|
# `head` = fração dos quadros com a CABEÇA visível (rosto com pontos OU só a caixa do detector, quando o MediaPipe
|
||||||
|
# perde o rosto de perfil); `head_motion` = caminho da cabeça em tamanhos de cabeça por segundo, sem os saltos de
|
||||||
|
# reaquisição; `hsize` = tamanho da caixa do detector nos quadros sem pontos (quem se inclina para a câmera de perfil).
|
||||||
|
BODY_FIELDS: tuple[str, ...] = ("shake", "nod", "head", "head_motion", "hsize")
|
||||||
|
EXTRA_SECOND_FIELDS: tuple[str, ...] = EXTRA_EXPRESSION_CHANNELS + POSE_FIELDS + BODY_FIELDS
|
||||||
|
_ONE_DECIMAL: frozenset[str] = frozenset(POSE_FIELDS + ("shake", "nod")) # graus e contagens: 1 casa basta
|
||||||
|
# Rótulos que não são reação: o pico sai como o "neutro" (bocejo abre a boca como grito, mas não é momento de corte).
|
||||||
|
NOT_REACTION: frozenset[str] = frozenset({"neutro", "bocejo"})
|
||||||
|
# Todos os rótulos de expressão (`label`, `yawn_seconds` e "alegria" do mapa); os de corpo estão em `BODY_PRIORITY`.
|
||||||
|
EXPRESSION_LABELS: tuple[str, ...] = (
|
||||||
|
"risada", "gargalhada", "alegria", "grito", "susto", "medo", "choque", "espanto", "confuso", "raiva", "nojo",
|
||||||
|
"tristeza", "tenso", "bocejo", "neutro",
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
@dataclass(frozen=True)
|
@dataclass(frozen=True)
|
||||||
class ReactionParams:
|
class ReactionParams:
|
||||||
@@ -62,6 +94,42 @@ class ReactionParams:
|
|||||||
raw_thresholds: dict[str, float] = field(default_factory=lambda: {
|
raw_thresholds: dict[str, float] = field(default_factory=lambda: {
|
||||||
"smile": 0.4, "jaw": 0.35, "surprise": 0.35, "frown": 0.35, "brow": 0.35, "motion": 0.5,
|
"smile": 0.4, "jaw": 0.35, "surprise": 0.35, "frown": 0.35, "brow": 0.35, "motion": 0.5,
|
||||||
}) # usados pelo `label` quando não há z (segundo isolado)
|
}) # usados pelo `label` quando não há z (segundo isolado)
|
||||||
|
# --- expressões a mais (EXTRA_EXPRESSION_CHANNELS) e corpo; calibrado em doc/clipador/EXPRESSOES.md ---
|
||||||
|
extra_floors: dict[str, float] = field(default_factory=lambda: {
|
||||||
|
"brow_inner": 0.10, "mouth_frown": 0.05, "squint": 0.06, "press": 0.08, "stretch": 0.06, "upper_lip": 0.10,
|
||||||
|
"pucker": 0.12, "head_motion": 0.15,
|
||||||
|
})
|
||||||
|
# Peso de cada expressão nova na INTENSIDADE (0 = só rotula). Ver o doc: com peso, viram picos sozinhas.
|
||||||
|
extra_weights: dict[str, float] = field(default_factory=lambda: {
|
||||||
|
"brow_inner": 0.0, "mouth_frown": 0.0, "squint": 0.0, "press": 0.0, "stretch": 0.0, "upper_lip": 0.0,
|
||||||
|
"pucker": 0.0,
|
||||||
|
})
|
||||||
|
extra_raw: dict[str, float] = field(default_factory=lambda: {
|
||||||
|
"brow_inner": 0.5, "mouth_frown": 0.3, "squint": 0.7, "press": 0.5, "stretch": 0.3, "upper_lip": 0.4,
|
||||||
|
"pucker": 0.6,
|
||||||
|
}) # limiares absolutos das expressões novas para o `label` sem z
|
||||||
|
yawn_jaw_raw: float = 0.5 # bocejo: boca muito aberta por ≥ `yawn_min_s` segundos seguidos…
|
||||||
|
yawn_min_s: int = 2
|
||||||
|
yawn_squint_z: float = 1.0 # …com os olhos apertando em algum deles (ver `yawn_seconds`)
|
||||||
|
disgust_smile_max: float = 0.3 # nojo só com o sorriso abaixo disto (valor absoluto)
|
||||||
|
laugh_jaw_raw: float = 0.3 # risada de boca escancarada = gargalhada
|
||||||
|
head_back_deg: float = 20.0 # cabeça jogada para trás: X graus acima do neutro dele (com risada = gargalhada)
|
||||||
|
map_z: float = 2.0 # mapa: segundo com sinal ≥ isto ganha rótulo de expressão (abaixo de `threshold`, sorriso = alegria)
|
||||||
|
# Corpo/cabeça
|
||||||
|
shake_deg: float = 8.0 # ida ou volta de pelo menos X graus no yaw conta como uma "perna" do balanço
|
||||||
|
nod_deg: float = 6.0 # idem no pitch (aceno)
|
||||||
|
osc_legs: int = 3 # pernas na janela de 2 s para "balançando"/"acenando" (2 = olhou para o lado e voltou)
|
||||||
|
head_min: float = 0.8 # cabeça visível em ≥ 80 % do segundo para o movimento valer (senão é o rastreio pulando)
|
||||||
|
head_max_step: float = 1.0 # passo máximo entre dois quadros, em tamanhos de cabeça (mais que isso = reaquisição)
|
||||||
|
agitation_z: float = 2.5 # agitação: movimento da cabeça com z ≥ isto…
|
||||||
|
agitation_window_s: int = 5 # …em pelo menos `agitation_min_s` segundos de uma janela deste tamanho
|
||||||
|
agitation_min_s: int = 3
|
||||||
|
lean_ratio: float = 1.18 # chegou perto: cabeça ≥ 18 % maior que o tamanho normal dele (p99,9 nas sessões 8/15)…
|
||||||
|
lean_min_s: int = 1 # …por pelo menos isto
|
||||||
|
leave_before_s: int = 3 # saiu do quadro: cabeça visível por ≥ 3 s…
|
||||||
|
leave_gone_s: int = 3 # …e depois sumida por ≥ 3 s (só com o campo `head`: série antiga não diz "saiu")
|
||||||
|
leave_gone_max: float = 0.1 # "sumida" = cabeça em no máximo 10 % dos quadros do segundo
|
||||||
|
leave_transition_s: int = 2 # segundos com a cabeça só em parte do quadro entre o "visível" e o "fora"
|
||||||
# --- câmera (locate_cam) ---
|
# --- câmera (locate_cam) ---
|
||||||
min_score: float = 0.6 # confiança mínima da detecção
|
min_score: float = 0.6 # confiança mínima da detecção
|
||||||
# Confiança MÉDIA mínima do grupo que vira câmera. Teste ao vivo de 17/11: webcam real (skipnho) 0,92–0,94 em
|
# Confiança MÉDIA mínima do grupo que vira câmera. Teste ao vivo de 17/11: webcam real (skipnho) 0,92–0,94 em
|
||||||
@@ -91,6 +159,9 @@ class FaceSample:
|
|||||||
cy: float = 0.0
|
cy: float = 0.0
|
||||||
size: float = 0.0
|
size: float = 0.0
|
||||||
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
|
blend: dict[str, float] = field(default_factory=dict) # nomes do MediaPipe (jawOpen, mouthSmileLeft…)
|
||||||
|
pose: tuple[float, float, float] | None = None # (yaw, pitch, roll) em graus; None = sem matriz de transformação
|
||||||
|
# Só a caixa da cabeça (detector), sem pontos nem blendshapes: `present` fica False e `cx`/`cy`/`size` são da caixa.
|
||||||
|
head: bool = False
|
||||||
|
|
||||||
|
|
||||||
@dataclass
|
@dataclass
|
||||||
@@ -109,20 +180,37 @@ class FaceSecond:
|
|||||||
brow: float | None = None
|
brow: float | None = None
|
||||||
blink: float | None = None
|
blink: float | None = None
|
||||||
motion: float | None = None
|
motion: float | None = None
|
||||||
|
# Mapa de expressões (EXTRA_SECOND_FIELDS): opcionais, ausentes na série gravada antes de 18/11/2026.
|
||||||
|
brow_inner: float | None = None
|
||||||
|
mouth_frown: float | None = None
|
||||||
|
squint: float | None = None
|
||||||
|
press: float | None = None
|
||||||
|
stretch: float | None = None
|
||||||
|
upper_lip: float | None = None
|
||||||
|
pucker: float | None = None
|
||||||
|
yaw: float | None = None
|
||||||
|
pitch: float | None = None
|
||||||
|
roll: float | None = None
|
||||||
|
shake: float | None = None
|
||||||
|
nod: float | None = None
|
||||||
|
head: float | None = None
|
||||||
|
head_motion: float | None = None
|
||||||
|
hsize: float | None = None
|
||||||
|
|
||||||
def to_json(self) -> dict:
|
def to_json(self) -> dict:
|
||||||
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`."""
|
"""Formato compacto para o banco/API: 3 casas (graus e contagens: 1), sem os campos `None`."""
|
||||||
out: dict = {"t": self.t, "present": round(self.present, 3)}
|
out: dict = {"t": self.t, "present": round(self.present, 3)}
|
||||||
for name in SECOND_FIELDS:
|
for name in SECOND_FIELDS + EXTRA_SECOND_FIELDS:
|
||||||
value = getattr(self, name)
|
value = getattr(self, name)
|
||||||
if value is not None:
|
if value is not None:
|
||||||
out[name] = round(value, 3)
|
out[name] = round(value, 1 if name in _ONE_DECIMAL else 3)
|
||||||
return out
|
return out
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def from_json(cls, data: dict) -> FaceSecond:
|
def from_json(cls, data: dict) -> FaceSecond:
|
||||||
return cls(int(data["t"]), float(data.get("present", 0.0)),
|
return cls(int(data["t"]), float(data.get("present", 0.0)),
|
||||||
**{n: (float(data[n]) if data.get(n) is not None else None) for n in SECOND_FIELDS})
|
**{n: (float(data[n]) if data.get(n) is not None else None)
|
||||||
|
for n in SECOND_FIELDS + EXTRA_SECOND_FIELDS})
|
||||||
|
|
||||||
|
|
||||||
@dataclass
|
@dataclass
|
||||||
@@ -177,13 +265,102 @@ def _channels(blend: dict[str, float]) -> dict[str, float]:
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> list[FaceSecond]:
|
def _extra_channels(blend: dict[str, float]) -> dict[str, float]:
|
||||||
|
"""Blendshapes do MediaPipe → expressões novas do mapa (EXTRA_EXPRESSION_CHANNELS), 0..1."""
|
||||||
|
def g(name: str) -> float:
|
||||||
|
return float(blend.get(name, 0.0))
|
||||||
|
|
||||||
|
return {
|
||||||
|
"brow_inner": g("browInnerUp"),
|
||||||
|
"mouth_frown": (g("mouthFrownLeft") + g("mouthFrownRight")) / 2,
|
||||||
|
"squint": (g("eyeSquintLeft") + g("eyeSquintRight")) / 2,
|
||||||
|
"press": (g("mouthPressLeft") + g("mouthPressRight")) / 2,
|
||||||
|
"stretch": (g("mouthStretchLeft") + g("mouthStretchRight")) / 2,
|
||||||
|
"upper_lip": (g("mouthUpperUpLeft") + g("mouthUpperUpRight")) / 2,
|
||||||
|
"pucker": max(g("mouthPucker"), g("mouthFunnel")),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def zigzag_legs(values: list[float], delta: float) -> list[float]:
|
||||||
|
"""Pernas de um zigue-zague com histerese `delta`: cada ida ou volta de pelo menos `delta` (amplitude).
|
||||||
|
|
||||||
|
Cabeça parada com tremida < `delta` → nenhuma perna; olhar para o lado e voltar → 2; balançar → 3 ou mais.
|
||||||
|
"""
|
||||||
|
legs: list[float] = []
|
||||||
|
if not values:
|
||||||
|
return legs
|
||||||
|
start = extreme = values[0]
|
||||||
|
direction = 0
|
||||||
|
for v in values[1:]:
|
||||||
|
if direction == 0:
|
||||||
|
if abs(v - start) >= delta:
|
||||||
|
direction, extreme = (1 if v > start else -1), v
|
||||||
|
legs.append(abs(v - start))
|
||||||
|
continue
|
||||||
|
if (v - extreme) * direction > 0: # continua na mesma direção: a perna cresce
|
||||||
|
legs[-1] += abs(v - extreme)
|
||||||
|
extreme = v
|
||||||
|
elif abs(v - extreme) >= delta: # virou com folga: perna nova
|
||||||
|
legs.append(abs(v - extreme))
|
||||||
|
direction, extreme = -direction, v
|
||||||
|
return legs
|
||||||
|
|
||||||
|
|
||||||
|
def _body_fields(out: list[FaceSecond], samples: list[FaceSample], first: int, p: ReactionParams) -> None:
|
||||||
|
"""Preenche pose, balanço/aceno e cabeça (EXTRA: série antiga não tem nada disto)."""
|
||||||
|
ordered = sorted(samples, key=lambda s: s.t)
|
||||||
|
posed = [s for s in ordered if s.present and s.pose is not None]
|
||||||
|
posed_t = [s.t for s in posed]
|
||||||
|
# Movimento da cabeça: passos entre quadros vizinhos da MESMA fonte (pontos × caixa do detector têm tamanhos
|
||||||
|
# diferentes), sem buraco de quadro perdido no meio e com o passo limitado: o "pulo" da reaquisição do rosto era o
|
||||||
|
# maior pico de movimento da live real.
|
||||||
|
visible = [s for s in ordered if (s.present or s.head) and s.size > 0]
|
||||||
|
paths = [0.0] * len(out)
|
||||||
|
for a, b in zip(visible, visible[1:]):
|
||||||
|
i = int(math.floor(b.t)) - first
|
||||||
|
if 0 <= i < len(out) and a.present == b.present and b.t - a.t <= 0.4:
|
||||||
|
step = (math.hypot(b.cx - a.cx, b.cy - a.cy) + abs(b.size - a.size)) / max(1e-6, (a.size + b.size) / 2)
|
||||||
|
paths[i] += min(step, p.head_max_step)
|
||||||
|
buckets: list[list[FaceSample]] = [[] for _ in out]
|
||||||
|
for s in ordered:
|
||||||
|
i = int(math.floor(s.t)) - first
|
||||||
|
if 0 <= i < len(out):
|
||||||
|
buckets[i].append(s)
|
||||||
|
for i, second in enumerate(out):
|
||||||
|
bucket = buckets[i]
|
||||||
|
if not bucket:
|
||||||
|
continue
|
||||||
|
seen = [s for s in bucket if (s.present or s.head) and s.size > 0]
|
||||||
|
second.head = len(seen) / len(bucket)
|
||||||
|
if seen:
|
||||||
|
second.head_motion = paths[i]
|
||||||
|
boxes = [s for s in seen if not s.present]
|
||||||
|
if boxes:
|
||||||
|
second.hsize = _mean([s.size for s in boxes])
|
||||||
|
poses = [s.pose for s in bucket if s.present and s.pose is not None]
|
||||||
|
if not poses:
|
||||||
|
continue
|
||||||
|
second.yaw, second.pitch, second.roll = (_mean([q[k] for q in poses]) for k in range(3))
|
||||||
|
# Janela de 2 s a partir de 0,5 s antes: um balanço de ~2 Hz a 6 qps tem 1–2 quadros por perna.
|
||||||
|
lo = bisect.bisect_left(posed_t, second.t - 0.5)
|
||||||
|
hi = bisect.bisect_left(posed_t, second.t + 1.5)
|
||||||
|
window = posed[lo:hi]
|
||||||
|
gaps = [b.t - a.t for a, b in zip(window, window[1:])]
|
||||||
|
if len(window) >= 6 and (not gaps or max(gaps) <= 0.4):
|
||||||
|
second.shake = float(len(zigzag_legs([s.pose[0] for s in window], p.shake_deg)))
|
||||||
|
second.nod = float(len(zigzag_legs([s.pose[1] for s in window], p.nod_deg)))
|
||||||
|
|
||||||
|
|
||||||
|
def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0,
|
||||||
|
params: ReactionParams | None = None) -> list[FaceSecond]:
|
||||||
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s).
|
"""Agrupa os quadros por segundo em [start_s, start_s + duration_s).
|
||||||
|
|
||||||
Posição/tamanho/piscar = média; expressões = máximo do segundo (a reação dura menos que 1 s às vezes);
|
Posição/tamanho/piscar = média; expressões = máximo do segundo (a reação dura menos que 1 s às vezes);
|
||||||
`motion` = caminho percorrido pelo centro (mais a variação de tamanho, quem se joga para a câmera) dividido
|
`motion` = caminho percorrido pelo centro (mais a variação de tamanho, quem se joga para a câmera) dividido
|
||||||
pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
|
pelo tamanho do rosto, ou seja, em "rostos por segundo" — independe do zoom da câmera.
|
||||||
|
Mapa de expressões: expressões novas (máximo), pose (média), balanço/aceno e cabeça — ver `_body_fields`.
|
||||||
"""
|
"""
|
||||||
|
p = params or ReactionParams()
|
||||||
n = max(0, int(math.ceil(duration_s)))
|
n = max(0, int(math.ceil(duration_s)))
|
||||||
first = int(math.floor(start_s))
|
first = int(math.floor(start_s))
|
||||||
buckets: list[list[FaceSample]] = [[] for _ in range(n)]
|
buckets: list[list[FaceSample]] = [[] for _ in range(n)]
|
||||||
@@ -204,6 +381,10 @@ def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.
|
|||||||
second.size = _mean([s.size for s in faces])
|
second.size = _mean([s.size for s in faces])
|
||||||
for name in ("smile", "jaw", "surprise", "frown", "brow"):
|
for name in ("smile", "jaw", "surprise", "frown", "brow"):
|
||||||
setattr(second, name, max(c[name] for c in channels))
|
setattr(second, name, max(c[name] for c in channels))
|
||||||
|
if any(s.blend for s in faces): # plano B (sem blendshapes) não inventa expressão nova
|
||||||
|
extra = [_extra_channels(s.blend) for s in faces]
|
||||||
|
for name in EXTRA_EXPRESSION_CHANNELS:
|
||||||
|
setattr(second, name, max(c[name] for c in extra))
|
||||||
second.blink = _mean([c["blink"] for c in channels])
|
second.blink = _mean([c["blink"] for c in channels])
|
||||||
path = 0.0
|
path = 0.0
|
||||||
for s in faces:
|
for s in faces:
|
||||||
@@ -213,6 +394,7 @@ def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.
|
|||||||
previous = s
|
previous = s
|
||||||
second.motion = path
|
second.motion = path
|
||||||
out.append(second)
|
out.append(second)
|
||||||
|
_body_fields(out, samples, first, p)
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
|
||||||
@@ -262,13 +444,71 @@ def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -
|
|||||||
if second.present < p.motion_min_present:
|
if second.present < p.motion_min_present:
|
||||||
z["motion"] = 0.0
|
z["motion"] = 0.0
|
||||||
out.append(z)
|
out.append(z)
|
||||||
|
_extra_z(seconds, face_idx, out, p)
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def rolling_baseline(seconds: list[FaceSecond], idx: list[int], name: str, floor: float,
|
||||||
|
p: ReactionParams) -> dict[int, tuple[float, float]]:
|
||||||
|
"""(mediana, desvio robusto) do campo `name` no neutro recente, para cada índice de `idx` (que já deve conter só
|
||||||
|
segundos com o campo). Mesma janela do `channel_z`; com menos de `min_baseline_n` segundos na série inteira,
|
||||||
|
devolve {} — canal novo numa série que mal começou a tê-lo não vira pico."""
|
||||||
|
if len(idx) < p.min_baseline_n:
|
||||||
|
return {}
|
||||||
|
values = [float(getattr(seconds[i], name)) for i in idx]
|
||||||
|
cache: dict[tuple[int, int], tuple[float, float]] = {}
|
||||||
|
out: dict[int, tuple[float, float]] = {}
|
||||||
|
for i in idx:
|
||||||
|
anchor = i - i % BASELINE_STEP_S
|
||||||
|
lo = bisect.bisect_left(idx, anchor - p.baseline_s)
|
||||||
|
hi = bisect.bisect_left(idx, anchor - p.exclude_recent_s)
|
||||||
|
if hi - lo < p.min_baseline_n:
|
||||||
|
lo, hi = 0, len(idx)
|
||||||
|
if (lo, hi) not in cache:
|
||||||
|
cache[(lo, hi)] = _robust(values[lo:hi], floor)
|
||||||
|
out[i] = cache[(lo, hi)]
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def _extra_z(seconds: list[FaceSecond], face_idx: list[int], out: list[dict[str, float] | None],
|
||||||
|
p: ReactionParams) -> None:
|
||||||
|
"""z das expressões novas e "cabeça para trás" (graus acima do neutro), no mesmo dict do `channel_z`.
|
||||||
|
|
||||||
|
Ao contrário dos canais antigos, o neutro de um canal novo usa SÓ os segundos que têm o campo: numa sessão em
|
||||||
|
que o serviço foi atualizado no meio, os segundos antigos (sem o campo) não podem virar um neutro de zeros.
|
||||||
|
"""
|
||||||
|
for name in EXTRA_EXPRESSION_CHANNELS:
|
||||||
|
idx = [i for i in face_idx if getattr(seconds[i], name) is not None]
|
||||||
|
base = rolling_baseline(seconds, idx, name, p.extra_floors.get(name, p.mad_floor), p)
|
||||||
|
for i in face_idx:
|
||||||
|
z = out[i]
|
||||||
|
if z is None:
|
||||||
|
continue
|
||||||
|
value = getattr(seconds[i], name)
|
||||||
|
if i in base and value is not None:
|
||||||
|
median, spread = base[i]
|
||||||
|
z[name] = (value - median) / spread
|
||||||
|
else:
|
||||||
|
z[name] = 0.0
|
||||||
|
# Pitch diminui quando a cabeça vai para trás (olhar para cima): "head_back" = neutro − pitch, em graus.
|
||||||
|
idx = [i for i in face_idx if seconds[i].pitch is not None]
|
||||||
|
base = rolling_baseline(seconds, idx, "pitch", 1.0, p)
|
||||||
|
for i in face_idx:
|
||||||
|
z = out[i]
|
||||||
|
if z is not None:
|
||||||
|
pitch = seconds[i].pitch
|
||||||
|
z["head_back"] = (base[i][0] - pitch) if (i in base and pitch is not None) else 0.0
|
||||||
|
|
||||||
|
|
||||||
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
|
def _signal_from_z(z: dict[str, float] | None, p: ReactionParams) -> float | None:
|
||||||
if z is None:
|
if z is None:
|
||||||
return None
|
return None
|
||||||
return max(0.0, max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS))
|
signal = max(p.weights.get(name, 1.0) * z[name] for name in EXPRESSION_CHANNELS)
|
||||||
|
for name in EXTRA_EXPRESSION_CHANNELS:
|
||||||
|
weight = p.extra_weights.get(name, 0.0)
|
||||||
|
if weight > 0:
|
||||||
|
signal = max(signal, weight * z.get(name, 0.0))
|
||||||
|
return max(0.0, signal)
|
||||||
|
|
||||||
|
|
||||||
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
|
def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
|
||||||
@@ -285,42 +525,75 @@ def reaction_signal(seconds: list[FaceSecond], baseline_s: int | None = None,
|
|||||||
|
|
||||||
|
|
||||||
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
|
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
|
||||||
"""Rótulo da expressão: risada, grito, susto, choque, confuso, raiva ou neutro.
|
"""Rótulo da expressão do segundo (um de `EXPRESSION_LABELS`; bocejo e alegria precisam de contexto e saem de
|
||||||
|
`yawn_seconds`/`expression_map`).
|
||||||
|
|
||||||
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
|
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
|
||||||
absolutos (`raw_thresholds`).
|
absolutos (`raw_thresholds`, `extra_raw`).
|
||||||
|
|
||||||
Regras (calibradas na live real, doc/FACE_BAKEOFF.md):
|
Regras (calibradas na live real, doc/FACE_BAKEOFF.md e doc/clipador/EXPRESSOES.md), na ordem:
|
||||||
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada,
|
- **risada** = sorriso subindo (sem exigir boca aberta: o streamer da bancada ri de boca quase fechada,
|
||||||
jawOpen ≤ 0,1); sorriso alto em valor absoluto também conta quando outro canal de rosto sobe junto (no
|
jawOpen ≤ 0,1); sorriso alto em valor absoluto também conta quando outro canal de rosto sobe junto (no
|
||||||
streamer que já sorri o tempo todo o sorriso não tem para onde subir);
|
streamer que já sorri o tempo todo o sorriso não tem para onde subir); com a cabeça jogada para trás =
|
||||||
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real:
|
**gargalhada**;
|
||||||
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**;
|
|
||||||
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
|
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
|
||||||
|
- **medo** = sobrancelha interna levantada + boca esticada para os lados (ou olho arregalado com a sobrancelha
|
||||||
|
descendo) — sem isso, olho arregalado é choque;
|
||||||
|
- **grito** = boca aberta sem sorriso, ou sobrancelha franzida com a boca ao menos entreaberta (no grito real:
|
||||||
|
browDown 0,61 + jawOpen 0,42 num segundo); franzida de boca fechada = **raiva**; olhos semicerrados + lábios
|
||||||
|
apertados com a sobrancelha descendo também é raiva; lábio de cima subindo com o sorriso já alto é risada;
|
||||||
|
- **nojo** = lábio de cima levantado sem sorriso e de boca fechada (`noseSneer` não funciona no MediaPipe);
|
||||||
|
- **tristeza** = cantos da boca para baixo + sobrancelha interna levantada, sem bico nem boca esticada (mão na
|
||||||
|
boca faz os dois);
|
||||||
|
- **espanto** = boca em "O" com a sobrancelha levantada ou a boca abrindo;
|
||||||
- **choque** = olho arregalado parado;
|
- **choque** = olho arregalado parado;
|
||||||
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
|
- **confuso** = sobrancelha levantada parada, sem sorriso (cara de "ué?" no lag: browInnerUp 0,27 de média
|
||||||
contra 0,02 no calmo).
|
contra 0,02 no calmo);
|
||||||
|
- **tenso** = lábios apertados + olhos semicerrados, sem sorriso (foco, tensão).
|
||||||
"""
|
"""
|
||||||
p = params or ReactionParams()
|
p = params or ReactionParams()
|
||||||
if second.smile is None:
|
if second.smile is None:
|
||||||
return "neutro"
|
return "neutro"
|
||||||
if z is not None:
|
if z is not None:
|
||||||
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS}
|
on = {name: z.get(name, 0.0) >= p.label_z for name in SIGNAL_CHANNELS + EXTRA_EXPRESSION_CHANNELS}
|
||||||
|
half = {name: z.get(name, 0.0) >= p.label_z / 2 for name in SIGNAL_CHANNELS + EXTRA_EXPRESSION_CHANNELS}
|
||||||
|
head_back = z.get("head_back", 0.0) >= p.head_back_deg
|
||||||
else:
|
else:
|
||||||
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
|
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
|
||||||
|
on |= {name: (getattr(second, name) or 0.0) >= p.extra_raw[name] for name in EXTRA_EXPRESSION_CHANNELS}
|
||||||
|
half = {name: on[name] for name in on}
|
||||||
|
head_back = False
|
||||||
smiling_raw = second.smile >= p.smile_raw
|
smiling_raw = second.smile >= p.smile_raw
|
||||||
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
|
jaw = second.jaw or 0.0
|
||||||
return "risada"
|
# Lábio de cima subindo com o sorriso já alto = rindo mostrando os dentes (sessão 8: 0,6–0,8 nas risadas).
|
||||||
|
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"] or on["upper_lip"])):
|
||||||
|
return "gargalhada" if head_back else "risada"
|
||||||
if (on["surprise"] or on["brow"]) and on["motion"]:
|
if (on["surprise"] or on["brow"]) and on["motion"]:
|
||||||
return "susto"
|
return "susto"
|
||||||
|
# Medo × choque (FACS): os dois levantam a sobrancelha e arregalam o olho; o medo estica a boca para os lados
|
||||||
|
# (AU20) ou junta a sobrancelha descendo (AU4).
|
||||||
|
if on["brow_inner"] and (on["stretch"] or (on["surprise"] and half["frown"])):
|
||||||
|
return "medo"
|
||||||
if on["jaw"]:
|
if on["jaw"]:
|
||||||
return "grito"
|
return "grito"
|
||||||
if on["frown"]:
|
if on["frown"]:
|
||||||
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva"
|
return "grito" if jaw >= p.shout_jaw_raw else "raiva"
|
||||||
|
if on["squint"] and on["press"] and half["frown"]:
|
||||||
|
return "raiva"
|
||||||
|
# Nojo só sem sorriso: o lábio de cima sobe junto em toda risada de dentes à mostra.
|
||||||
|
if on["upper_lip"] and not half["jaw"] and second.smile < p.disgust_smile_max:
|
||||||
|
return "nojo"
|
||||||
|
# Mão na boca (tique comum: queixo apoiado, coçar o nariz) faz bico e estica a boca: aí não é tristeza.
|
||||||
|
if on["mouth_frown"] and half["brow_inner"] and not on["pucker"] and not on["stretch"]:
|
||||||
|
return "tristeza"
|
||||||
|
if on["pucker"] and (on["brow"] or half["jaw"]):
|
||||||
|
return "espanto"
|
||||||
if on["surprise"]:
|
if on["surprise"]:
|
||||||
return "choque"
|
return "choque"
|
||||||
if on["brow"]:
|
if on["brow"]:
|
||||||
return "confuso"
|
return "confuso"
|
||||||
|
if on["press"] and on["squint"]:
|
||||||
|
return "tenso"
|
||||||
return "neutro"
|
return "neutro"
|
||||||
|
|
||||||
|
|
||||||
@@ -351,9 +624,10 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
|
|||||||
run[i] = current
|
run[i] = current
|
||||||
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
|
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
|
||||||
chosen: list[tuple[int, str]] = []
|
chosen: list[tuple[int, str]] = []
|
||||||
|
yawns = yawn_seconds(seconds, zs, p)
|
||||||
for peak in candidates:
|
for peak in candidates:
|
||||||
name = _peak_label(seconds, zs, peak, p)
|
name = _peak_label(seconds, zs, peak, p, yawns)
|
||||||
if name == "neutro" and not p.keep_neutral:
|
if name in NOT_REACTION and not p.keep_neutral:
|
||||||
continue
|
continue
|
||||||
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento.
|
# Perto demais de um pico maior, ou mesma reação no mesmo trecho contínuo → é o mesmo momento.
|
||||||
if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
|
if any(abs(peak - j) < p.min_gap_s or (run[peak] == run[j] and name == other) for j, other in chosen):
|
||||||
@@ -372,12 +646,32 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
|
|||||||
return moments
|
return moments
|
||||||
|
|
||||||
|
|
||||||
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str:
|
def yawn_seconds(seconds: list[FaceSecond], zs: list[dict[str, float] | None], p: ReactionParams) -> set[int]:
|
||||||
|
"""Índices dos segundos de bocejo: boca muito aberta (jawOpen ≥ `yawn_jaw_raw`) por ≥ `yawn_min_s` segundos
|
||||||
|
seguidos, com os olhos apertando (z do `squint` ≥ `yawn_squint_z`) em algum deles.
|
||||||
|
|
||||||
|
Sessão 8 (skipnho, fim de live): os 5 trechos com jawOpen ≥ 0,6 por 3 s eram todos bocejos (olhos fechados,
|
||||||
|
braços esticando) e eram os maiores "gritos" da sessão (z 12–16); os gritos e exclamações de verdade abriram a
|
||||||
|
boca assim por 1 s só. O bocejo também levanta o "sorriso" (cantos esticados): por isso vem antes da risada.
|
||||||
|
"""
|
||||||
|
wide = [(s.jaw or 0.0) >= p.yawn_jaw_raw and zs[i] is not None for i, s in enumerate(seconds)]
|
||||||
|
out: set[int] = set()
|
||||||
|
for i, j in _runs(wide, 0):
|
||||||
|
if j - i + 1 >= p.yawn_min_s and any((zs[k] or {}).get("squint", 0.0) >= p.yawn_squint_z
|
||||||
|
for k in range(i, j + 1)):
|
||||||
|
out.update(range(i, j + 1))
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams,
|
||||||
|
yawns: set[int] | None = None) -> str:
|
||||||
|
if yawns and peak in yawns:
|
||||||
|
return "bocejo"
|
||||||
name = label(seconds[peak], zs[peak], p)
|
name = label(seconds[peak], zs[peak], p)
|
||||||
if name == "neutro":
|
if name == "neutro":
|
||||||
for j in (peak - 1, peak + 1):
|
for j in (peak - 1, peak + 1):
|
||||||
if 0 <= j < len(seconds) and zs[j] is not None:
|
if 0 <= j < len(seconds) and zs[j] is not None:
|
||||||
other = label(seconds[j], zs[j], p)
|
other = "bocejo" if yawns and j in yawns else label(seconds[j], zs[j], p)
|
||||||
if other != "neutro":
|
if other != "neutro":
|
||||||
return other
|
return other
|
||||||
return name
|
return name
|
||||||
@@ -385,32 +679,199 @@ def _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], pe
|
|||||||
|
|
||||||
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
|
def summarize(seconds: list[FaceSecond], start_s: float = 0.0, end_s: float | None = None,
|
||||||
params: ReactionParams | None = None, max_items: int = 4,
|
params: ReactionParams | None = None, max_items: int = 4,
|
||||||
moments: list[ReactionMoment] | None = None, relative: bool = True) -> str:
|
moments: list[ReactionMoment] | None = None, relative: bool = True,
|
||||||
|
body: list[BodyMoment] | None = None) -> str:
|
||||||
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho.
|
"""Texto curto para o juiz sobre o rosto no trecho [start_s, end_s], com tempos relativos ao início do trecho.
|
||||||
|
|
||||||
Passe a série inteira (ou bem mais que o trecho): o neutro do streamer vem do que veio antes.
|
Passe a série inteira (ou bem mais que o trecho): o neutro do streamer vem do que veio antes.
|
||||||
Ex.: "risada forte em 12 s; susto em 15 s". `moments` (opcional): picos já calculados com `reaction_moments`
|
Ex.: "risada forte em 12 s; susto em 15 s". `moments` (opcional): picos já calculados com `reaction_moments`
|
||||||
sobre a série inteira — evita recalcular a live toda a cada corte (~1 s por hora de live).
|
sobre a série inteira — evita recalcular a live toda a cada corte (~1 s por hora de live).
|
||||||
`relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
|
`relative=False`: tempos da gravação ("risada forte em 1628s"), como o resto do prompt do juiz.
|
||||||
|
Corpo/cabeça (`body_moments`, ou `body` já calculado) entra no fim: "balançando a cabeça em 15 s". Com a cabeça
|
||||||
|
visível mas sem expressão legível (de perfil, longe), o texto diz isso e traz só o corpo.
|
||||||
"""
|
"""
|
||||||
p = params or ReactionParams()
|
p = params or ReactionParams()
|
||||||
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s)
|
end = end_s if end_s is not None else (seconds[-1].t + 1 if seconds else start_s)
|
||||||
inside = [s for s in seconds if start_s <= s.t <= end]
|
inside = [s for s in seconds if start_s <= s.t <= end]
|
||||||
|
|
||||||
|
def when(t: float) -> str:
|
||||||
|
return f"{int(round(t - start_s))} s" if relative else f"{t:.0f}s"
|
||||||
|
|
||||||
|
body_parts = [f"{BODY_TEXT.get(b.label, b.label)} em {when(b.peak_s)}"
|
||||||
|
for b in (body if body is not None else body_moments(seconds, p)) if start_s <= b.peak_s <= end]
|
||||||
with_face = [s for s in inside if _has_face(s, p)]
|
with_face = [s for s in inside if _has_face(s, p)]
|
||||||
if not with_face:
|
if not with_face:
|
||||||
|
heads = [s for s in inside if (s.head or 0.0) >= p.min_present]
|
||||||
|
if not inside or len(heads) < max(1, len(inside) // 3):
|
||||||
return "rosto do streamer não aparece no trecho"
|
return "rosto do streamer não aparece no trecho"
|
||||||
|
text = (f"rosto sem expressão legível (de perfil ou longe; cabeça visível em "
|
||||||
|
f"{int(round(100 * len(heads) / len(inside)))}% do trecho)")
|
||||||
|
return text + ("; " + "; ".join(body_parts[:max_items]) if body_parts else "; sem movimento marcante")
|
||||||
parts = []
|
parts = []
|
||||||
for m in (moments if moments is not None else reaction_moments(seconds, p)):
|
for m in (moments if moments is not None else reaction_moments(seconds, p)):
|
||||||
if start_s <= m.peak_s <= end:
|
if start_s <= m.peak_s <= end:
|
||||||
when = f"{int(round(m.peak_s - start_s))} s" if relative else f"{m.peak_s:.0f}s"
|
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when(m.peak_s)}")
|
||||||
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when}")
|
|
||||||
presence = len(with_face) / len(inside)
|
presence = len(with_face) / len(inside)
|
||||||
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
|
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
|
||||||
|
if body_parts:
|
||||||
|
text += "; " + "; ".join(body_parts[:2])
|
||||||
if presence < 0.7:
|
if presence < 0.7:
|
||||||
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
|
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
|
||||||
return text
|
return text
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------------------------------------------
|
||||||
|
# Corpo/cabeça e mapa de expressões
|
||||||
|
|
||||||
|
# Texto de cada rótulo de corpo no resumo do juiz.
|
||||||
|
BODY_TEXT: dict[str, str] = {
|
||||||
|
"balançando": "balançando a cabeça", "acenando": "acenando com a cabeça", "agitado": "agitado na cadeira",
|
||||||
|
"chegou perto": "chegou perto da câmera", "saiu do quadro": "saiu do quadro",
|
||||||
|
}
|
||||||
|
BODY_PRIORITY: tuple[str, ...] = ("saiu do quadro", "chegou perto", "agitado", "balançando", "acenando")
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class BodyMoment:
|
||||||
|
"""Movimento da cabeça/corpo num trecho (mesmo sem expressão no rosto)."""
|
||||||
|
|
||||||
|
start_s: int
|
||||||
|
end_s: int
|
||||||
|
peak_s: int
|
||||||
|
label: str # balançando | acenando | agitado | chegou perto | saiu do quadro
|
||||||
|
value: float # pernas do balanço, z do movimento, razão do tamanho ou segundos fora, conforme o rótulo
|
||||||
|
|
||||||
|
def to_json(self) -> dict:
|
||||||
|
return {"startS": self.start_s, "endS": self.end_s, "peakS": self.peak_s, "label": self.label,
|
||||||
|
"value": round(self.value, 2)}
|
||||||
|
|
||||||
|
|
||||||
|
def _head_ok(second: FaceSecond, p: ReactionParams) -> bool:
|
||||||
|
"""Cabeça bem visível no segundo inteiro (rastreio sem pulos). Série antiga: usa o rosto."""
|
||||||
|
if second.head is not None:
|
||||||
|
return second.head >= p.head_min
|
||||||
|
return second.present >= p.motion_min_present
|
||||||
|
|
||||||
|
|
||||||
|
def _runs(flags: list[bool], max_gap: int = 1) -> list[tuple[int, int]]:
|
||||||
|
"""Trechos [i, j] de índices ligados, juntando buracos de até `max_gap` segundos."""
|
||||||
|
out: list[tuple[int, int]] = []
|
||||||
|
for i, on in enumerate(flags):
|
||||||
|
if not on:
|
||||||
|
continue
|
||||||
|
if out and i - out[-1][1] <= max_gap + 1:
|
||||||
|
out[-1] = (out[-1][0], i)
|
||||||
|
else:
|
||||||
|
out.append((i, i))
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def body_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[BodyMoment]:
|
||||||
|
"""Balanço, aceno, agitação, chegar perto e sair do quadro — relativos ao normal do próprio streamer.
|
||||||
|
|
||||||
|
Rastreio perdido nunca vira movimento: só contam segundos com a cabeça em ≥ `head_min` dos quadros, o passo
|
||||||
|
entre quadros é limitado (`head_max_step`) e a agitação exige a janela inteira com a cabeça visível.
|
||||||
|
"""
|
||||||
|
p = params or ReactionParams()
|
||||||
|
n = len(seconds)
|
||||||
|
ok = [_head_ok(s, p) for s in seconds]
|
||||||
|
out: list[BodyMoment] = []
|
||||||
|
|
||||||
|
def add(name: str, i: int, j: int, values: list[float]) -> None:
|
||||||
|
k = max(range(i, j + 1), key=lambda x: values[x])
|
||||||
|
out.append(BodyMoment(seconds[i].t, seconds[j].t, seconds[k].t, name, values[k]))
|
||||||
|
|
||||||
|
shake = [(s.shake or 0.0) if ok[i] else 0.0 for i, s in enumerate(seconds)]
|
||||||
|
nod = [(s.nod or 0.0) if ok[i] else 0.0 for i, s in enumerate(seconds)]
|
||||||
|
for i, j in _runs([v >= p.osc_legs for v in shake], 0):
|
||||||
|
add("balançando", i, j, shake)
|
||||||
|
for i, j in _runs([nod[k] >= p.osc_legs and shake[k] < p.osc_legs for k in range(n)], 0):
|
||||||
|
add("acenando", i, j, nod)
|
||||||
|
|
||||||
|
# Agitação: movimento da cabeça bem acima do normal dele em vários segundos de uma janela sem rastreio perdido.
|
||||||
|
idx = [i for i, s in enumerate(seconds) if ok[i] and s.head_motion is not None]
|
||||||
|
base = rolling_baseline(seconds, idx, "head_motion", p.extra_floors.get("head_motion", 0.15), p)
|
||||||
|
motion_z = [0.0] * n
|
||||||
|
for i in idx:
|
||||||
|
if i in base:
|
||||||
|
median, spread = base[i]
|
||||||
|
motion_z[i] = ((seconds[i].head_motion or 0.0) - median) / spread
|
||||||
|
hot = [False] * n
|
||||||
|
w = p.agitation_window_s
|
||||||
|
for i in range(0, max(0, n - w + 1)):
|
||||||
|
window = range(i, i + w)
|
||||||
|
if all(ok[k] for k in window) and sum(motion_z[k] >= p.agitation_z for k in window) >= p.agitation_min_s:
|
||||||
|
for k in window:
|
||||||
|
hot[k] = hot[k] or motion_z[k] >= p.agitation_z
|
||||||
|
for i, j in _runs(hot, 1):
|
||||||
|
add("agitado", i, j, motion_z)
|
||||||
|
|
||||||
|
# Chegou perto: cabeça bem maior que o tamanho normal dele (rosto com pontos e caixa do detector têm escalas
|
||||||
|
# diferentes: cada um contra o próprio neutro).
|
||||||
|
ratio = [0.0] * n
|
||||||
|
sources = (("size", lambda s: s.present >= p.motion_min_present and bool(s.size)),
|
||||||
|
("hsize", lambda s: s.hsize is not None and s.present < p.min_present))
|
||||||
|
for name, has in sources:
|
||||||
|
idx = [i for i, s in enumerate(seconds) if ok[i] and has(s)]
|
||||||
|
base = rolling_baseline(seconds, idx, name, 1e-6, p)
|
||||||
|
for i in idx:
|
||||||
|
if i in base and base[i][0] > 0:
|
||||||
|
ratio[i] = float(getattr(seconds[i], name)) / base[i][0]
|
||||||
|
for i, j in _runs([r >= p.lean_ratio for r in ratio], 0):
|
||||||
|
if j - i + 1 >= p.lean_min_s:
|
||||||
|
add("chegou perto", i, j, ratio)
|
||||||
|
|
||||||
|
# Saiu do quadro: só com o campo `head` (a caixa do detector segue a cabeça de perfil; sem ele, o MediaPipe
|
||||||
|
# perdendo o rosto pareceria saída). Segundo sem dado nenhum (bloco não rastreado) não conta como fora.
|
||||||
|
# Levantar e sair leva 1–2 s com a cabeça só em parte do segundo (sessão 15: "++" antes do vazio): até
|
||||||
|
# `leave_transition_s` segundos parciais entre o "visível" e o "fora" contam como a saída.
|
||||||
|
gone = [s.head is not None and s.head <= p.leave_gone_max for s in seconds]
|
||||||
|
for i, j in _runs(gone, 0):
|
||||||
|
if j - i + 1 < p.leave_gone_s:
|
||||||
|
continue
|
||||||
|
start = i
|
||||||
|
while (start > 0 and i - start < p.leave_transition_s and seconds[start - 1].head is not None
|
||||||
|
and p.leave_gone_max < (seconds[start - 1].head or 0.0) < p.head_min):
|
||||||
|
start -= 1
|
||||||
|
before = range(max(0, start - p.leave_before_s), start)
|
||||||
|
if len(before) == p.leave_before_s and all(
|
||||||
|
seconds[k].head is not None and (seconds[k].head or 0.0) >= p.head_min for k in before):
|
||||||
|
out.append(BodyMoment(seconds[start].t, seconds[j].t, seconds[start].t, "saiu do quadro",
|
||||||
|
float(j - i + 1)))
|
||||||
|
return sorted(out, key=lambda b: (b.start_s, BODY_PRIORITY.index(b.label)))
|
||||||
|
|
||||||
|
|
||||||
|
def expression_map(seconds: list[FaceSecond], params: ReactionParams | None = None,
|
||||||
|
body: list[BodyMoment] | None = None) -> list[dict]:
|
||||||
|
"""Mapa de expressões: por segundo, a expressão dominante (`expr`) e o movimento do corpo (`body`).
|
||||||
|
|
||||||
|
`expr`: `None` sem rosto; senão o rótulo do segundo (`label` com o z do neutro do streamer). Sorriso que não chega
|
||||||
|
a pico (sinal < `threshold`) é **alegria**, não risada. `body`: rótulo do `body_moments` que cobre o segundo
|
||||||
|
(prioridade: saiu do quadro > chegou perto > agitado > balançando > acenando) ou `None`.
|
||||||
|
"""
|
||||||
|
p = params or ReactionParams()
|
||||||
|
zs = channel_z(seconds, p)
|
||||||
|
yawns = yawn_seconds(seconds, zs, p)
|
||||||
|
out = []
|
||||||
|
for i, (second, z) in enumerate(zip(seconds, zs)):
|
||||||
|
expr = None
|
||||||
|
if z is not None:
|
||||||
|
expr = "bocejo" if i in yawns else label(second, z, p)
|
||||||
|
# Sorriso sem pico e sem boca abrindo/dentes à mostra = alegria; rindo de dentes à mostra continua risada.
|
||||||
|
if (expr == "risada" and (_signal_from_z(z, p) or 0.0) < p.threshold
|
||||||
|
and z.get("jaw", 0.0) < p.label_z and z.get("upper_lip", 0.0) < p.label_z):
|
||||||
|
expr = "alegria"
|
||||||
|
out.append({"t": second.t, "expr": expr, "body": None})
|
||||||
|
first = seconds[0].t if seconds else 0
|
||||||
|
for b in sorted(body if body is not None else body_moments(seconds, p),
|
||||||
|
key=lambda b: -BODY_PRIORITY.index(b.label)): # o mais importante escreve por último
|
||||||
|
for t in range(b.start_s, b.end_s + 1):
|
||||||
|
i = t - first
|
||||||
|
if 0 <= i < len(out):
|
||||||
|
out[i]["body"] = b.label
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
# ---------------------------------------------------------------------------------------------------------------
|
# ---------------------------------------------------------------------------------------------------------------
|
||||||
# Onde está a câmera
|
# Onde está a câmera
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,309 @@
|
|||||||
|
"""Mapa de expressões (reaction.py + face.py): expressões novas, pose/corpo e compatibilidade com a série antiga.
|
||||||
|
|
||||||
|
Séries sintéticas no formato da live real (doc/clipador/EXPRESSOES.md): neutro com ruído pequeno e eventos injetados.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import json
|
||||||
|
import math
|
||||||
|
import random
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
from app import face as face_mod
|
||||||
|
from app.reaction import (
|
||||||
|
EXTRA_SECOND_FIELDS, FaceSample, FaceSecond, ReactionParams, body_moments, channel_z, expression_map, label,
|
||||||
|
per_second, reaction_moments, seconds_from_json, seconds_to_json, summarize, yawn_seconds, zigzag_legs,
|
||||||
|
)
|
||||||
|
from tests.test_face import CAM, make_service, set_cam
|
||||||
|
from tests.test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
|
||||||
|
|
||||||
|
FPS = 6
|
||||||
|
|
||||||
|
|
||||||
|
def calm(n: int = 300, seed: int = 1, head: bool = True) -> list[FaceSecond]:
|
||||||
|
"""Neutro como o do skipnho (sessão 8): sorriso baixo, olhos semicerrados ~0,45, lábios um pouco apertados."""
|
||||||
|
rng = random.Random(seed)
|
||||||
|
out = []
|
||||||
|
for t in range(n):
|
||||||
|
s = FaceSecond(t, 1.0, 0.5, 0.4, 0.3, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.02),
|
||||||
|
surprise=rng.uniform(0.0, 0.004), frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.02, 0.1),
|
||||||
|
blink=0.5, motion=rng.uniform(0.02, 0.15))
|
||||||
|
s.brow_inner = rng.uniform(0.02, 0.1)
|
||||||
|
s.mouth_frown = rng.uniform(0.0, 0.01)
|
||||||
|
s.squint = rng.uniform(0.4, 0.5)
|
||||||
|
s.press = rng.uniform(0.05, 0.12)
|
||||||
|
s.stretch = rng.uniform(0.0, 0.03)
|
||||||
|
s.upper_lip = rng.uniform(0.0, 0.02)
|
||||||
|
s.pucker = rng.uniform(0.0, 0.05)
|
||||||
|
s.yaw, s.pitch, s.roll = rng.uniform(-3, 3), 12 + rng.uniform(-2, 2), rng.uniform(-2, 2)
|
||||||
|
s.shake, s.nod = float(rng.choice([0, 0, 1])), float(rng.choice([0, 0, 1]))
|
||||||
|
if head:
|
||||||
|
s.head, s.head_motion = 1.0, rng.uniform(0.05, 0.3)
|
||||||
|
out.append(s)
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def expr_at(seconds: list[FaceSecond], t: int) -> str | None:
|
||||||
|
return expression_map(seconds)[t]["expr"]
|
||||||
|
|
||||||
|
|
||||||
|
# --- expressões novas -------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize("name,changes", [
|
||||||
|
("medo", {"brow_inner": 0.7, "brow": 0.7, "stretch": 0.4}),
|
||||||
|
("tristeza", {"mouth_frown": 0.35, "brow_inner": 0.3}),
|
||||||
|
("nojo", {"upper_lip": 0.6}),
|
||||||
|
("espanto", {"pucker": 0.7, "brow": 0.6}),
|
||||||
|
("tenso", {"press": 0.5, "squint": 0.75}),
|
||||||
|
("raiva", {"press": 0.5, "squint": 0.75, "frown": 0.15}),
|
||||||
|
])
|
||||||
|
def test_each_new_expression_fires_on_its_pattern(name, changes):
|
||||||
|
seconds = calm()
|
||||||
|
for key, value in changes.items():
|
||||||
|
setattr(seconds[200], key, value)
|
||||||
|
assert expr_at(seconds, 200) == name
|
||||||
|
# Os vizinhos continuam neutros.
|
||||||
|
assert expr_at(seconds, 190) == "neutro" and expr_at(seconds, 210) == "neutro"
|
||||||
|
|
||||||
|
|
||||||
|
def test_neutral_has_no_new_expression_nor_body():
|
||||||
|
emap = expression_map(calm(600, seed=4))
|
||||||
|
assert {e["expr"] for e in emap} <= {"neutro"}
|
||||||
|
assert all(e["body"] is None for e in emap)
|
||||||
|
|
||||||
|
|
||||||
|
def test_upper_lip_with_big_smile_is_laughing_not_disgust():
|
||||||
|
# Sessão 8: todo "nojo" da 1ª rodada era risada de dentes à mostra (sorriso 0,9 já normal dele, lábio de cima 0,4–0,8).
|
||||||
|
seconds = calm()
|
||||||
|
for s in seconds:
|
||||||
|
s.smile = 0.9 + (s.t % 3) * 0.02
|
||||||
|
seconds[200].upper_lip = 0.6
|
||||||
|
assert expr_at(seconds, 200) == "risada"
|
||||||
|
|
||||||
|
|
||||||
|
def test_laugh_with_head_thrown_back_is_gargalhada_and_small_smile_is_alegria():
|
||||||
|
seconds = calm()
|
||||||
|
seconds[200].smile, seconds[200].pitch = 0.9, -15.0 # 27° acima do neutro dele (+12°)
|
||||||
|
seconds[250].smile = 0.9
|
||||||
|
seconds[280].smile = 0.33 # sorriso acima do neutro, mas sem chegar a pico
|
||||||
|
emap = expression_map(seconds)
|
||||||
|
assert emap[200]["expr"] == "gargalhada" and emap[250]["expr"] == "risada" and emap[280]["expr"] == "alegria"
|
||||||
|
|
||||||
|
|
||||||
|
def test_yawn_is_not_a_scream_and_never_a_peak():
|
||||||
|
# Sessão 8: os 5 trechos de jawOpen ≥ 0,6 por 3 s eram bocejos e eram os maiores "gritos" (z 12–16).
|
||||||
|
seconds = calm()
|
||||||
|
for t in range(150, 153):
|
||||||
|
seconds[t].jaw, seconds[t].squint = 0.75, 0.7
|
||||||
|
seconds[250].jaw = 0.75 # boca escancarada por 1 s: grito
|
||||||
|
zs = channel_z(seconds)
|
||||||
|
assert yawn_seconds(seconds, zs, ReactionParams()) == {150, 151, 152}
|
||||||
|
assert expr_at(seconds, 151) == "bocejo"
|
||||||
|
assert [(m.peak_s, m.label) for m in reaction_moments(seconds)] == [(250, "grito")]
|
||||||
|
|
||||||
|
|
||||||
|
def test_new_channels_only_label_unless_weighted():
|
||||||
|
# Peso 0 (padrão): tristeza aparece no mapa, mas não vira pico; com peso, vira.
|
||||||
|
seconds = calm()
|
||||||
|
seconds[200].mouth_frown, seconds[200].brow_inner = 0.4, 0.3
|
||||||
|
assert reaction_moments(seconds) == []
|
||||||
|
weighted = ReactionParams(extra_weights={"mouth_frown": 1.0})
|
||||||
|
assert [(m.peak_s, m.label) for m in reaction_moments(seconds, weighted)] == [(200, "tristeza")]
|
||||||
|
|
||||||
|
|
||||||
|
def test_label_without_z_uses_raw_thresholds_for_new_channels():
|
||||||
|
second = calm(1)[0]
|
||||||
|
second.upper_lip = 0.6
|
||||||
|
assert label(second) == "nojo"
|
||||||
|
|
||||||
|
|
||||||
|
# --- corpo / cabeça pela pose -----------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def posed(duration: int, yaw=lambda t: 0.0, pitch=lambda t: 12.0, size=lambda t: 0.3, cx=lambda t: 0.5,
|
||||||
|
present=lambda t: True, head=lambda t: False) -> list[FaceSample]:
|
||||||
|
rng = random.Random(7)
|
||||||
|
out = []
|
||||||
|
for i in range(duration * FPS):
|
||||||
|
t = i / FPS
|
||||||
|
if present(t):
|
||||||
|
blend = {"mouthSmileLeft": 0.05, "mouthSmileRight": 0.05, "jawOpen": 0.01}
|
||||||
|
pose = (yaw(t) + rng.uniform(-1, 1), pitch(t) + rng.uniform(-1, 1), rng.uniform(-1, 1))
|
||||||
|
out.append(FaceSample(t, True, cx(t) + rng.uniform(-0.003, 0.003), 0.4, size(t), blend, pose))
|
||||||
|
elif head(t):
|
||||||
|
out.append(FaceSample(t, False, cx(t), 0.4, size(t), head=True))
|
||||||
|
else:
|
||||||
|
out.append(FaceSample(t, False))
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def window(lo: float, hi: float, fn, rest=0.0):
|
||||||
|
return lambda t: fn(t) if lo <= t < hi else rest
|
||||||
|
|
||||||
|
|
||||||
|
def test_zigzag_counts_back_and_forth():
|
||||||
|
assert zigzag_legs([0, 1, -1, 2, 0], 8) == []
|
||||||
|
assert len(zigzag_legs([0, 20, 0], 8)) == 2 # olhou para o lado e voltou
|
||||||
|
assert len(zigzag_legs([0, 15, -15, 15, -15], 8)) == 4
|
||||||
|
|
||||||
|
|
||||||
|
def test_head_shake_and_nod_from_pose():
|
||||||
|
shake = window(100, 103, lambda t: 15 * math.sin(2 * math.pi * 1.2 * t))
|
||||||
|
nod = window(200, 203, lambda t: 12 + 10 * math.sin(2 * math.pi * 1.2 * t), 12.0)
|
||||||
|
glance = window(250, 251.5, lambda t: 30 * math.sin(math.pi * (t - 250) / 1.5)) # vira e volta uma vez
|
||||||
|
seconds = per_second(posed(300, yaw=lambda t: shake(t) + glance(t), pitch=nod), 300)
|
||||||
|
labels = [(b.label, b.start_s) for b in body_moments(seconds)]
|
||||||
|
assert any(name == "balançando" and 99 <= s <= 101 for name, s in labels)
|
||||||
|
assert any(name == "acenando" and 199 <= s <= 202 for name, s in labels)
|
||||||
|
assert not any(name == "balançando" and 248 <= s <= 252 for name, s in labels)
|
||||||
|
assert seconds[50].yaw is not None and abs(seconds[50].pitch - 12) < 2
|
||||||
|
|
||||||
|
|
||||||
|
def test_lost_face_is_not_agitation_but_real_movement_is():
|
||||||
|
# Rastreio piscando: rosto some e volta noutro lugar a cada meio segundo (o "pico" de movimento da live real).
|
||||||
|
flicker = lambda t: not (100 <= t < 110 and int(t * 2) % 2 == 1) # noqa: E731
|
||||||
|
jump = window(100, 110, lambda t: 0.3 * (int(t * 2) % 4 == 0), 0.0)
|
||||||
|
moving = window(200, 206, lambda t: 0.12 * math.sin(2 * math.pi * 2.5 * t))
|
||||||
|
seconds = per_second(posed(300, present=flicker, cx=lambda t: 0.5 + jump(t) + moving(t)), 300)
|
||||||
|
agitated = [b for b in body_moments(seconds) if b.label == "agitado"]
|
||||||
|
assert agitated and all(199 <= b.start_s and b.end_s <= 206 for b in agitated)
|
||||||
|
|
||||||
|
|
||||||
|
def test_leaving_the_frame_and_leaning_in():
|
||||||
|
gone = lambda t: not (150 <= t < 170) # noqa: E731
|
||||||
|
seconds = per_second(posed(300, present=gone, size=window(80, 83, lambda t: 0.42, 0.3)), 300)
|
||||||
|
labels = {(b.label, b.start_s) for b in body_moments(seconds)}
|
||||||
|
assert ("saiu do quadro", 150) in labels
|
||||||
|
assert any(name == "chegou perto" and 80 <= s <= 82 for name, s in labels)
|
||||||
|
|
||||||
|
|
||||||
|
def test_head_box_keeps_the_body_when_the_face_is_in_profile():
|
||||||
|
# Sessão 15 (tfue de perfil): MediaPipe em 10 % dos quadros, YuNet em 100 %. A caixa da cabeça não é "rosto".
|
||||||
|
in_profile = lambda t: t < 30 # noqa: E731
|
||||||
|
out = lambda t: not (150 <= t < 160) # noqa: E731
|
||||||
|
samples = posed(300, present=in_profile, head=out)
|
||||||
|
seconds = per_second(samples, 300)
|
||||||
|
assert seconds[100].present == 0.0 and seconds[100].smile is None and seconds[100].head == 1.0
|
||||||
|
assert seconds[100].hsize == pytest.approx(0.3) and seconds[155].head == 0.0
|
||||||
|
assert ("saiu do quadro", 150) in {(b.label, b.start_s) for b in body_moments(seconds)}
|
||||||
|
text = summarize(seconds, 140, 170)
|
||||||
|
assert text.startswith("rosto sem expressão legível") and "saiu do quadro em 10 s" in text
|
||||||
|
|
||||||
|
|
||||||
|
# --- compatibilidade --------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_old_series_without_new_fields_still_works():
|
||||||
|
seconds = calm()
|
||||||
|
seconds[200].smile = 0.9
|
||||||
|
data = seconds_to_json(seconds)
|
||||||
|
for d in data:
|
||||||
|
for name in EXTRA_SECOND_FIELDS:
|
||||||
|
d.pop(name, None)
|
||||||
|
old = seconds_from_json(json.loads(json.dumps(data)))
|
||||||
|
assert old[0].brow_inner is None and old[0].head is None
|
||||||
|
assert [m.label for m in reaction_moments(old)] == ["risada"]
|
||||||
|
assert body_moments(old) == [] # sem `head` não há "saiu do quadro"; sem pose, nem balanço
|
||||||
|
assert {e["expr"] for e in expression_map(old)} <= {"neutro", "risada"}
|
||||||
|
|
||||||
|
|
||||||
|
def test_service_updated_mid_session_does_not_fake_new_expressions():
|
||||||
|
# Primeira metade gravada antes (sem os campos novos), segunda com eles: o neutro do canal novo usa só a segunda.
|
||||||
|
seconds = calm(400)
|
||||||
|
for s in seconds[:200]:
|
||||||
|
for name in EXTRA_SECOND_FIELDS:
|
||||||
|
setattr(s, name, None)
|
||||||
|
emap = expression_map(seconds)
|
||||||
|
assert {e["expr"] for e in emap} <= {"neutro"}
|
||||||
|
assert body_moments(seconds) == []
|
||||||
|
|
||||||
|
|
||||||
|
def test_new_fields_roundtrip_compact():
|
||||||
|
s = calm(1)[0]
|
||||||
|
data = s.to_json()
|
||||||
|
assert set(EXTRA_SECOND_FIELDS) - {"hsize"} <= set(data)
|
||||||
|
assert data["yaw"] == round(s.yaw, 1) and len(str(data["squint"]).split(".")[-1]) <= 3
|
||||||
|
back = FaceSecond.from_json(json.loads(json.dumps(data)))
|
||||||
|
assert back.hsize is None and abs(back.squint - s.squint) < 1e-3
|
||||||
|
|
||||||
|
|
||||||
|
# --- face.py ----------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_pose_from_matrix():
|
||||||
|
a = math.radians(20)
|
||||||
|
rx = [[1, 0, 0, 0], [0, math.cos(a), -math.sin(a), 0], [0, math.sin(a), math.cos(a), 0], [0, 0, 0, 1]]
|
||||||
|
yaw, pitch, roll = face_mod.pose_from_matrix(rx)
|
||||||
|
assert pitch == pytest.approx(20) and abs(yaw) < 1e-6 and abs(roll) < 1e-6
|
||||||
|
ry = [[math.cos(a), 0, math.sin(a), 0], [0, 1, 0, 0], [-math.sin(a), 0, math.cos(a), 0], [0, 0, 0, 1]]
|
||||||
|
assert face_mod.pose_from_matrix(ry)[0] == pytest.approx(20)
|
||||||
|
|
||||||
|
|
||||||
|
class FakeDetector:
|
||||||
|
def __init__(self, result=None, error=None):
|
||||||
|
self.result, self.error, self.calls = result or [], error, 0
|
||||||
|
|
||||||
|
def detect(self, bgr):
|
||||||
|
self.calls += 1
|
||||||
|
assert bgr.shape == (40, 80, 3)
|
||||||
|
if self.error:
|
||||||
|
raise self.error
|
||||||
|
return self.result
|
||||||
|
|
||||||
|
|
||||||
|
def tracker_with(detector):
|
||||||
|
tracker = object.__new__(face_mod.MediaPipeTracker) # sem carregar o MediaPipe: só o caminho da caixa da cabeça
|
||||||
|
tracker._np, tracker._detector = np, detector
|
||||||
|
return tracker
|
||||||
|
|
||||||
|
|
||||||
|
def test_tracker_head_box_when_mediapipe_loses_the_face():
|
||||||
|
rgb = np.zeros((40, 80, 3), np.uint8)
|
||||||
|
sample = tracker_with(FakeDetector([(10, 4, 20, 20, 0.7), (40, 10, 16, 20, 0.9)]))._head_only(1.5, rgb)
|
||||||
|
assert sample.present is False and sample.head is True and sample.blend == {}
|
||||||
|
assert sample.cx == pytest.approx(0.6) and sample.cy == pytest.approx(0.5) and sample.size == pytest.approx(0.5)
|
||||||
|
assert tracker_with(FakeDetector([]))._head_only(1.5, rgb) == FaceSample(1.5, False)
|
||||||
|
assert tracker_with(FakeDetector(error=RuntimeError("cv2")))._head_only(1.5, rgb) == FaceSample(1.5, False)
|
||||||
|
assert tracker_with(None)._head_only(1.5, rgb) == FaceSample(1.5, False)
|
||||||
|
|
||||||
|
|
||||||
|
def test_to_frame_converts_head_size():
|
||||||
|
second = FaceSecond(0, 0.0, hsize=0.5)
|
||||||
|
assert face_mod.to_frame([second], CAM)[0].hsize == pytest.approx(0.25)
|
||||||
|
|
||||||
|
|
||||||
|
class PosedTracker:
|
||||||
|
"""Rosto com pose: sorriso alto em `laughs`; balanço da cabeça em `shakes`."""
|
||||||
|
|
||||||
|
name = "fake"
|
||||||
|
|
||||||
|
def __init__(self, laughs=(), shakes=()):
|
||||||
|
self.laughs, self.shakes = set(laughs), set(shakes)
|
||||||
|
|
||||||
|
def process(self, t, rgb):
|
||||||
|
smile = 0.9 if int(t) in self.laughs else 0.05 + 0.05 * ((int(t * 6) % 3) / 2)
|
||||||
|
yaw = 15 * math.sin(2 * math.pi * 1.2 * t) if int(t) in self.shakes else 0.0
|
||||||
|
return FaceSample(t, True, 0.5, 0.4, 0.3, {"mouthSmileLeft": smile, "mouthSmileRight": smile},
|
||||||
|
(yaw, 12.0, 0.0))
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def test_face_api_has_the_expression_map_and_body(env): # noqa: F811
|
||||||
|
client, engine = env
|
||||||
|
service = make_service(engine, tracker_factory=lambda _b=None: PosedTracker(range(300, 306), range(310, 313)))
|
||||||
|
sid = seed_session(engine)
|
||||||
|
set_cam(engine, sid)
|
||||||
|
while service.step():
|
||||||
|
pass
|
||||||
|
body = client.get(f"/v1/sessions/{sid}/face?from=290&to=320", headers=auth()).json()
|
||||||
|
by_t = {s["t"]: s for s in body["seconds"]}
|
||||||
|
assert by_t[302]["expr"] == "risada" and by_t[295]["expr"] == "neutro"
|
||||||
|
assert by_t[311]["body"] == "balançando" and "body" not in by_t[295]
|
||||||
|
assert "yaw" in by_t[295] and by_t[295]["head"] == 1.0
|
||||||
|
assert [b["label"] for b in body["body"]] == ["balançando"]
|
||||||
|
line = service.summary(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid), 295, 315)
|
||||||
|
assert "risada" in line and "balançando a cabeça em 3" in line
|
||||||
@@ -0,0 +1,210 @@
|
|||||||
|
# Mapa de expressões do streamer (Clipador)
|
||||||
|
|
||||||
|
Data: 18/11/2026. Código: `clipper/app/reaction.py` (lógica pura) e `clipper/app/face.py` (MediaPipe/YuNet, API);
|
||||||
|
painel: `panel/src/components/clipper-face-map.tsx`. Testes: `clipper/tests/test_expressions.py`. Base anterior:
|
||||||
|
[`doc/FACE_BAKEOFF.md`](../FACE_BAKEOFF.md) e a seção "Rastreio de reação" do `clipper/README.md`.
|
||||||
|
|
||||||
|
Pedido do dono: "Está muito pouco, tem que colocar mais expressões. Às vezes ele não tem expressão facial, mas a
|
||||||
|
gente pega ele balançando… raiva, medo, alegria — está faltando para deixar mais completo o mapa de expressões."
|
||||||
|
|
||||||
|
Antes: 8 dos 52 blendshapes do MediaPipe viravam 5 canais (`smile`, `jaw`, `surprise`, `frown`, `brow`) + `motion`,
|
||||||
|
e 6 rótulos (risada, grito, susto, choque, confuso, raiva). Sem pose da cabeça e sem nada quando o rosto some.
|
||||||
|
|
||||||
|
## O que mudou
|
||||||
|
|
||||||
|
1. **Expressões novas** a partir dos blendshapes que já vinham (custo zero).
|
||||||
|
2. **Pose da cabeça**: o Face Landmarker agora devolve a matriz de transformação facial
|
||||||
|
(`output_facial_transformation_matrixes=True`) → yaw/pitch/roll por quadro (`face.pose_from_matrix`).
|
||||||
|
3. **Cabeça sem rosto**: quando o MediaPipe não acha o rosto (streamer de perfil), o YuNet (já usado para achar a
|
||||||
|
câmera; mesma licença MIT) roda **só nesse quadro** e dá a caixa da cabeça → posição/tamanho para o corpo.
|
||||||
|
4. **Corpo**: balançando, acenando, agitado, chegou perto, saiu do quadro (`reaction.body_moments`).
|
||||||
|
5. **Mapa**: expressão dominante + corpo por segundo (`reaction.expression_map`), na API e no modal do corte.
|
||||||
|
|
||||||
|
Nada disso mexe na **intensidade** do rosto (o sinal que vira pico, bônus na nota e corte de fonte `face`): os
|
||||||
|
canais novos só **rotulam** (pesos `extra_weights` = 0; ver "Por que os canais novos não viram pico"). A única
|
||||||
|
mudança nos picos é o **bocejo**, que deixou de contar como grito.
|
||||||
|
|
||||||
|
## Canais por segundo (campos novos da série, todos opcionais)
|
||||||
|
|
||||||
|
Série antiga (gravada antes) não tem estes campos: tudo continua funcionando (canal ausente = parado). Sem
|
||||||
|
migração de banco — os campos vão no `data_json` de `face_track` que já existia.
|
||||||
|
|
||||||
|
| Campo | De onde vem | Agregação no segundo |
|
||||||
|
|---|---|---|
|
||||||
|
| `brow_inner` | `browInnerUp` | máximo |
|
||||||
|
| `mouth_frown` | média `mouthFrownLeft/Right` (cantos da boca para baixo) | máximo |
|
||||||
|
| `squint` | média `eyeSquintLeft/Right` (olhos semicerrados) | máximo |
|
||||||
|
| `press` | média `mouthPressLeft/Right` (lábios apertados) | máximo |
|
||||||
|
| `stretch` | média `mouthStretchLeft/Right` (boca esticada para os lados) | máximo |
|
||||||
|
| `upper_lip` | média `mouthUpperUpLeft/Right` (lábio de cima levantado) | máximo |
|
||||||
|
| `pucker` | maior entre `mouthPucker` e `mouthFunnel` (boca em "O") | máximo |
|
||||||
|
| `yaw`, `pitch`, `roll` | matriz de transformação facial, graus (1 casa) | média |
|
||||||
|
| `shake`, `nod` | pernas de zigue-zague do yaw/pitch (histerese 8°/6°) na janela [t−0,5; t+1,5) s | contagem |
|
||||||
|
| `head` | fração dos quadros com a cabeça visível (rosto com pontos **ou** caixa do YuNet) | fração |
|
||||||
|
| `head_motion` | caminho da cabeça em tamanhos de cabeça, só entre quadros vizinhos (≤ 0,4 s) da mesma fonte, passo limitado a 1 | soma |
|
||||||
|
| `hsize` | altura da caixa do YuNet nos quadros sem pontos (fração do quadro inteiro) | média |
|
||||||
|
|
||||||
|
Blendshapes **mortos** no modelo do MediaPipe (medido: máximo ≤ 0,001 em 4 sessões, ~45 mil segundos):
|
||||||
|
`noseSneerLeft/Right`, `cheekSquintLeft/Right`, `cheekPuff`. Por isso nojo e raiva **não** usam o nariz: o lábio de
|
||||||
|
cima (`upper_lip`) faz o papel.
|
||||||
|
|
||||||
|
O z de cada canal novo é o mesmo esquema do `channel_z` (mediana + 1,4826 × MAD dos últimos 180 s do próprio
|
||||||
|
streamer, sem os últimos 10 s), mas o neutro usa **só os segundos que têm o campo**: numa sessão em que o serviço
|
||||||
|
foi atualizado no meio, os segundos antigos não viram um "neutro de zeros" (teste
|
||||||
|
`test_service_updated_mid_session_does_not_fake_new_expressions`). Menos de 30 segundos com o campo → z 0. Pisos
|
||||||
|
do desvio (`extra_floors`): `brow_inner` 0,10, `mouth_frown` 0,05, `squint` 0,06, `press` 0,08, `stretch` 0,06,
|
||||||
|
`upper_lip` 0,10, `pucker` 0,12, `head_motion` 0,15.
|
||||||
|
|
||||||
|
## Rótulos de expressão (`label`, `yawn_seconds`, `expression_map`)
|
||||||
|
|
||||||
|
"Ligado" = z ≥ 2 (`label_z`); "meio" = z ≥ 1. Ordem de decisão:
|
||||||
|
|
||||||
|
| Rótulo | Regra | Observação |
|
||||||
|
|---|---|---|
|
||||||
|
| **bocejo** | jawOpen ≥ 0,5 por ≥ 2 s seguidos e `squint` z ≥ 1 em algum deles | contexto (`yawn_seconds`); **não é reação**: o pico sai |
|
||||||
|
| **risada** | sorriso ligado; ou sorriso ≥ 0,5 com boca, franzido, sobrancelha **ou lábio de cima** ligado | lábio de cima: novo |
|
||||||
|
| **gargalhada** | risada com a cabeça ≥ 20° para trás do neutro dele (`head_back_deg`) | novo |
|
||||||
|
| **alegria** | (só no mapa) risada sem pico (sinal < 3), sem boca abrindo e sem dentes à mostra | novo |
|
||||||
|
| **susto** | sobrancelha ou olho arregalado + movimento | igual |
|
||||||
|
| **medo** | `brow_inner` ligado + `stretch` ligado (ou olho arregalado com a sobrancelha descendo) | novo; FACS AU1+AU20 |
|
||||||
|
| **grito** | boca ligada; ou franzido com a boca ≥ 0,2 | igual |
|
||||||
|
| **raiva** | franzido de boca fechada; **ou** `squint` + `press` ligados com o franzido "meio" | 2ª forma: nova |
|
||||||
|
| **nojo** | `upper_lip` ligado, boca abaixo de "meio" e sorriso < 0,3 | novo |
|
||||||
|
| **tristeza** | `mouth_frown` ligado + `brow_inner` "meio", sem `pucker` nem `stretch` ligados | novo |
|
||||||
|
| **espanto** | `pucker` ligado + sobrancelha ligada ou boca "meio" | novo |
|
||||||
|
| **choque** | olho arregalado parado | igual |
|
||||||
|
| **confuso** | sobrancelha levantada parada | igual |
|
||||||
|
| **tenso** | `press` + `squint` ligados (sem franzido) | novo (painel: "tensão") |
|
||||||
|
|
||||||
|
## Corpo/cabeça (`body_moments`)
|
||||||
|
|
||||||
|
Só contam segundos com a cabeça em ≥ 80 % dos quadros (`head_min`; série antiga: o rosto). Rastreio perdido
|
||||||
|
nunca vira movimento (achado do FACE_BAKEOFF: os maiores "picos" de movimento eram o rosto sumindo e voltando): o
|
||||||
|
passo entre quadros é limitado, quadros com buraco > 0,4 s entre eles não somam, pontos e caixa do YuNet não se
|
||||||
|
misturam, e a agitação exige a janela inteira com a cabeça visível (teste `test_lost_face_is_not_agitation…`).
|
||||||
|
|
||||||
|
| Rótulo | Regra |
|
||||||
|
|---|---|
|
||||||
|
| **balançando** | `shake` ≥ 3 pernas (vai-volta-vai de ≥ 8° no yaw em 2 s). Olhar para o lado e voltar = 2: não conta |
|
||||||
|
| **acenando** | `nod` ≥ 3 pernas (≥ 6° no pitch) sem balanço lateral |
|
||||||
|
| **agitado** | `head_motion` com z ≥ 2,5 em ≥ 3 de 5 s seguidos, todos com a cabeça visível |
|
||||||
|
| **chegou perto** | cabeça ≥ 18 % maior que o tamanho normal dele (rosto e caixa do YuNet, cada um contra o próprio neutro) |
|
||||||
|
| **saiu do quadro** | cabeça visível ≥ 3 s, até 2 s de transição parcial, depois ≤ 10 % por ≥ 3 s. **Só com o campo `head`** (série antiga não diz "saiu": lá o MediaPipe perdendo o rosto pareceria saída) |
|
||||||
|
|
||||||
|
## Onde aparece
|
||||||
|
|
||||||
|
- **API** `GET /v1/sessions/{id}/face`: cada segundo ganha `expr` (expressão do mapa) e `body` (movimento), além
|
||||||
|
dos campos novos; a resposta ganha `body: [{startS, endS, peakS, label, value}]`. Os picos (`moments`) podem vir
|
||||||
|
com os rótulos novos.
|
||||||
|
- **Juiz (analista)**: a linha "Rosto do streamer" traz até 2 movimentos do corpo no fim ("…; balançando a cabeça
|
||||||
|
em 1628s"). Com o rosto de perfil o tempo todo, antes não ia linha nenhuma; agora vai "rosto sem expressão legível
|
||||||
|
(de perfil ou longe; cabeça visível em 95% do trecho); saiu do quadro em 187s".
|
||||||
|
- **Painel**: `FaceSignal` (chip do corte) mostra os rótulos novos em português; o modal do corte ganhou o **Mapa de
|
||||||
|
expressões** (`clipper-face-map.tsx`): faixa com uma célula por segundo, cor por família (verde alegria/risada,
|
||||||
|
amarelo susto/espanto/medo, vermelho raiva/grito/nojo, azul tristeza/tensão, violeta confuso), faixa laranja do
|
||||||
|
corpo embaixo, legenda com segundos por expressão e os movimentos. Busca o trecho do corte; sem câmera ou serviço
|
||||||
|
antigo, não aparece.
|
||||||
|
|
||||||
|
## Calibração (dados reais, só leitura)
|
||||||
|
|
||||||
|
Banco copiado por `sqlite3.backup` (`mode=ro`); blocos `.ts` só lidos; MediaPipe rodado num script à parte com as
|
||||||
|
classes do `face.py` (matriz de pose ligada), quadros salvos fora do repositório. Cada regra foi conferida **olhando
|
||||||
|
os quadros** (folhas de contato de 8 quadros em volta de cada caso).
|
||||||
|
|
||||||
|
| Sessão | Canal | O que tem | Segundos com rosto (MediaPipe) |
|
||||||
|
|---|---|---|---|
|
||||||
|
| 8 | skipnho (PT), 1,7 h | 206 blocos, 14 cortes | 6009 de 6162 |
|
||||||
|
| 11 | skipnho (PT), 30 min | 59 blocos, 3 cortes | 1763 de 1770 |
|
||||||
|
| 7 | skipnho (PT), fim da live | 79 blocos ainda no disco (2217 s), 6 cortes | — |
|
||||||
|
| 15 | tfue (EN), gravando | 125 blocos, 27 cortes (13 descartados pela IA) | **486 de 3750** |
|
||||||
|
|
||||||
|
Achados que mudaram as regras:
|
||||||
|
|
||||||
|
- **Bocejo era o maior "grito"**: na sessão 8 os 5 trechos com jawOpen ≥ 0,6 por 3 s (1420, 3335, 3437, 3483 e
|
||||||
|
3659 s) eram todos bocejos (olhos fechados, braços esticando), com z 12–16. Gritos e exclamações abriram a boca
|
||||||
|
assim por 1 s (908, 2331 s). O bocejo ainda levanta o "sorriso" (cantos esticados): z 4–8. Regra de contexto
|
||||||
|
(≥ 2 s + olhos apertando) pegou os 5 (+1 em 5662 s) e nenhum grito de 1 s; o piscar não serve (o normal deste
|
||||||
|
streamer já é 0,5).
|
||||||
|
- **Nojo × risada**: a 1ª regra (lábio de cima sem boca aberta) deu 82 trechos na sessão 8; todos eram risada de
|
||||||
|
dentes à mostra (sorriso 0,91–0,97, que para ele já é quase o normal: z ~1). Com o sorriso < 0,3 exigido e o lábio
|
||||||
|
de cima contando para a risada: 5 trechos.
|
||||||
|
- **Mão no rosto engana a boca**: queixo apoiado, mão na boca e coçar o nariz (tique frequente do skipnho) fazem
|
||||||
|
`mouth_frown`, `stretch` e `pucker` subirem (911, 3984–3987, 4060, 5077, 5222 s). Não há sinal de oclusão no
|
||||||
|
MediaPipe (comparei os 52 blendshapes nesses segundos com o resto: nenhum separa). Tristeza passou a excluir bico
|
||||||
|
e boca esticada; o resto fica como limitação documentada (ver "Por que os canais novos não viram pico").
|
||||||
|
- **Cabeça para trás**: a 12° deu 16 "gargalhadas" na sessão 8, quase todas falsas (pose errada com a mão no rosto,
|
||||||
|
falando). A 20° fica a gargalhada real de 1566 s (24°, cabeça para trás com as mãos no rosto) e cai o resto, menos
|
||||||
|
uma: em 2572 s a cadeira estava **vazia** e o MediaPipe inventou um rosto no encosto (28°). Bebendo de lata também
|
||||||
|
vai a −25° (pitch), por isso "cabeça para trás" sozinha não vira rótulo — só com risada.
|
||||||
|
- **Balanço a 6 qps**: 28 eventos (δ 8°, ≥ 3 pernas) na sessão 8; nos quadros, eram cabeça indo e voltando
|
||||||
|
rindo, falando ou gesticulando — não dá para afirmar "não" literal a 6 qps (uma perna dura 1–2 quadros). Por isso o
|
||||||
|
rótulo é "balançando a cabeça", não "disse não". Olhar para o lado e voltar (1225, 2832 s) dá 2 pernas e fica fora.
|
||||||
|
- **Agitado**: 64 trechos na sessão 8; conferidos 6 — todos movimento de verdade (se inclinando para fora e
|
||||||
|
voltando, gesticulando, se espreguiçando).
|
||||||
|
- **Chegou perto**: razão tamanho/normal p99 1,15 e p99,9 1,21 (sessão 8); o 1,25 inicial não pegava nada. Com 1,18:
|
||||||
|
13 trechos na 8 (ex.: 2066 s, rosto colado na câmera), 1 na 15.
|
||||||
|
- **tfue de perfil (sessão 15)**: o MediaPipe acha rosto em **10 %** dos quadros (yaw mediano −44°: olha o monitor
|
||||||
|
ao lado da webcam); o YuNet acha a cabeça em **100 %** (180/180 em 4 blocos, score 0,89). Com a caixa do YuNet:
|
||||||
|
cabeça visível em 85 % dos segundos e **4 saídas do quadro**, que batem com os cortes: 187 s (corte 261 "Tfue Takes
|
||||||
|
a Bathroom Break Mid-Stream", 175–244), 577 s (corte 268 "…Waiting on a Bathroom Break", 518–581; tirou o fone e
|
||||||
|
levantou), 1236–1333 s (tela de "volto já" cobrindo a câmera) e 3572 s (corte 285). Sem a tolerância de 2 s de
|
||||||
|
transição (ele levanta em 1–2 s) só a 3ª aparecia. Raiva forte em 977/1011 s cai nos cortes 265/272 ("Base Is
|
||||||
|
Under Attack by Suspected Stream Snipers").
|
||||||
|
|
||||||
|
Resultado final (picos = `reaction_moments`; mapa = % dos segundos com rosto):
|
||||||
|
|
||||||
|
| Sessão | Picos antes → depois | Trocas de rótulo nos picos | Mapa (fora o neutro) | Corpo (eventos) |
|
||||||
|
|---|---|---|---|---|
|
||||||
|
| 8 | 251 → 254 (8 bocejos saíram, a seleção gulosa reescolheu vizinhos) | confuso→espanto 3, confuso→tristeza 1, risada→gargalhada 1 | risada 14,8 %, confuso 6,5, alegria 5,1, grito 1,5, susto 1,1, espanto 0,9, raiva 0,7, tristeza 0,3, bocejo 0,3, medo 0,2, nojo 0,1, tenso 0,1 | agitado 64, balançando 42, acenando 36, chegou perto 13 |
|
||||||
|
| 11 | 107 → 107 | confuso→tristeza 1, confuso→espanto 1, risada→gargalhada 1 | risada 19,0 %, confuso 6,0, alegria 5,3, susto 1,9, grito 0,9, espanto 0,7 | agitado 18, acenando 10, balançando 5 |
|
||||||
|
| 7 | 144 → 144 | confuso→espanto 3, grito→medo 1 | risada 12,9 %, alegria 8,3, confuso 6,9, grito 3,5, raiva 2,1, espanto 2,1 | acenando 10, balançando 7, agitado 4 |
|
||||||
|
| 15 | 22 → 22 | risada→gargalhada 1 | raiva 10,5 %, risada 4,7, confuso 2,9, grito 2,3 | agitado 9, saiu do quadro 4, balançando 3, acenando 3 |
|
||||||
|
|
||||||
|
(Sessões 7, 8 e 11 sem a caixa do YuNet na calibração — lá o rosto aparece em 97–99 % dos segundos; o "saiu do
|
||||||
|
quadro" delas vem do rosto sumindo e não entra na tabela.)
|
||||||
|
|
||||||
|
## Por que os canais novos não viram pico
|
||||||
|
|
||||||
|
Com peso na intensidade, cada canal novo criaria picos sozinho — e os falsos mais comuns (mão no rosto) caem
|
||||||
|
justamente nos canais da boca. A intensidade alimenta a nota dos cortes e a fonte `face`; mexer nela sem um conjunto
|
||||||
|
aprovado/rejeitado maior seria chute (nas sessões 7, 8 e 11 quase todos os cortes estão "ready", sem decisão do
|
||||||
|
dono). Então: `extra_weights` = 0 e os canais novos só **rotulam** o pico que as expressões antigas já acharam, e
|
||||||
|
pintam o mapa. Para ligar um canal na intensidade, é só dar peso em `ReactionParams.extra_weights` (testado no
|
||||||
|
código: `_signal_from_z`), depois de medir de novo.
|
||||||
|
|
||||||
|
## Custo (medido, mesma máquina: 32 threads, CPU; 6 blocos de 30 s por caso, rodados em sequência)
|
||||||
|
|
||||||
|
| Caso | Bloco antes | Bloco depois | `per_second` | JSON da série |
|
||||||
|
|---|---|---|---|---|
|
||||||
|
| skipnho (rosto em 100 % dos quadros) | 1775 ms (máx 2124) | 1773 ms (máx 2047) | 0,7 → 1,5 ms | 177 → 400 B/s |
|
||||||
|
| tfue de perfil (rosto em 1 %, só cabeça em 73 %) | 1238 ms (máx 1573) | 1721 ms (máx 2236) | 0,2 → 0,3 ms | 36 → 85 B/s |
|
||||||
|
|
||||||
|
- A matriz de pose não custa nada mensurável. O YuNet custa **5,3 ms por quadro sem rosto** (média de 20 255 quadros
|
||||||
|
da sessão 15) e só roda nesses quadros: streamer de frente não paga nada; de perfil, +0,5 s por bloco de 30 s
|
||||||
|
(ainda ~17× mais rápido que o tempo real).
|
||||||
|
- Banco: ~1,4 MB por hora de live em `face_track` (antes ~0,6 MB).
|
||||||
|
- Análise (`reaction_moments` + `body_moments` + `expression_map`) numa série de 1,7 h: ~1 s.
|
||||||
|
|
||||||
|
## Limitações conhecidas (não verificadas ou fora do alcance)
|
||||||
|
|
||||||
|
- **Mão no rosto** ainda pode virar tristeza/espanto/medo/raiva no mapa (ver calibração).
|
||||||
|
- **Rosto fantasma**: com a cadeira vazia o MediaPipe às vezes acha um rosto no encosto (sessão 8, 2567–2575 s,
|
||||||
|
presença 0,3–1,0 em segundos soltos); aparece no mapa como expressão. O "saiu do quadro" ainda pega a saída quando
|
||||||
|
há ≥ 3 s seguidos sem rosto.
|
||||||
|
- **Sim/não literal** não é medido (6 qps); "balançando/acenando" é o movimento, não a intenção.
|
||||||
|
- Serviço real rodando o código novo **não** foi testado (o serviço é do dono; só scripts com as classes e a suíte).
|
||||||
|
A caixa do YuNet dentro do `FaceService` foi coberta por teste com detector falso e medida por script com o real.
|
||||||
|
- Painel: só `tsc`; não abri no navegador.
|
||||||
|
- Nenhuma sessão com câmera escura/minúscula além da do tfue (rosto ~66 px de altura na fonte 1080p).
|
||||||
|
|
||||||
|
## Integração com o agente de Falantes (atividade da boca)
|
||||||
|
|
||||||
|
- Nada foi renomeado nem removido: `SECOND_FIELDS`, `FaceSample.blend`, `per_second`, `FaceSecond`,
|
||||||
|
`seconds_to_json/from_json` continuam iguais para quem já usa. Os campos novos estão em `EXTRA_SECOND_FIELDS`
|
||||||
|
(`to_json`/`from_json` percorrem `SECOND_FIELDS + EXTRA_SECOND_FIELDS`).
|
||||||
|
- `FaceSample` ganhou `pose` e `head` com padrão (`None`/`False`); quadro com `head=True` tem `present=False` e
|
||||||
|
**não tem blendshapes** — quem medir a boca deve continuar filtrando por `present`.
|
||||||
|
- `per_second` ganhou o parâmetro opcional `params` (só para os limiares do balanço). A atividade da boca para fala
|
||||||
|
pode usar `jaw`, `pucker` (bico/funil), `press`, `stretch`, `upper_lip` por segundo, que agora vêm na série.
|
||||||
|
- Ponto provável de conflito de merge: os dois agentes acrescentam campos ao fim de `FaceSecond` e uma tupla de
|
||||||
|
campos opcionais; manter as duas listas.
|
||||||
@@ -113,10 +113,33 @@ export type CamDetect = {
|
|||||||
confidence?: number; fullFrame?: boolean;
|
confidence?: number; fullFrame?: boolean;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
/** Expressões do rosto (reaction.py, `EXPRESSION_LABELS`). Serviço antigo só manda as 7 primeiras. */
|
||||||
|
export type FaceExpression = "risada" | "grito" | "susto" | "choque" | "confuso" | "raiva" | "neutro"
|
||||||
|
| "gargalhada" | "alegria" | "medo" | "espanto" | "nojo" | "tristeza" | "tenso" | "bocejo";
|
||||||
|
/** Movimento da cabeça/corpo (reaction.py, `body_moments`), mesmo sem expressão no rosto. */
|
||||||
|
export type BodyLabel = "balançando" | "acenando" | "agitado" | "chegou perto" | "saiu do quadro";
|
||||||
|
|
||||||
/** Reação no rosto do streamer (rastreio local, reaction.py): pico, início e intensidade (z relativo ao normal dele). */
|
/** Reação no rosto do streamer (rastreio local, reaction.py): pico, início e intensidade (z relativo ao normal dele). */
|
||||||
export type FaceReaction = {
|
export type FaceReaction = {
|
||||||
peakS: number; onsetS: number; endS: number; intensity: number; strong: boolean;
|
peakS: number; onsetS: number; endS: number; intensity: number; strong: boolean;
|
||||||
label: "risada" | "grito" | "susto" | "choque" | "confuso" | "raiva" | "neutro";
|
label: FaceExpression;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Um segundo do mapa de expressões (`GET sessions/{id}/face`); só os campos que o painel usa. */
|
||||||
|
export type FaceMapSecond = {
|
||||||
|
t: number; present: number;
|
||||||
|
/** Expressão dominante; ausente = sem rosto legível (ou serviço antigo). */
|
||||||
|
expr?: FaceExpression;
|
||||||
|
/** Movimento do corpo que cobre o segundo; ausente = nada. */
|
||||||
|
body?: BodyLabel;
|
||||||
|
/** Fração dos quadros com a cabeça visível (inclui a caixa do detector com o rosto de perfil). */
|
||||||
|
head?: number;
|
||||||
|
};
|
||||||
|
export type BodyMoment = { startS: number; endS: number; peakS: number; label: BodyLabel; value: number };
|
||||||
|
export type FaceView = {
|
||||||
|
fromS: number; toS: number; seconds: FaceMapSecond[]; moments: FaceReaction[];
|
||||||
|
/** Ausente no serviço antigo. */
|
||||||
|
body?: BodyMoment[];
|
||||||
};
|
};
|
||||||
|
|
||||||
export type Situation = "lag_ou_bug" | "jogada" | "falha_engracada" | "morte" | "susto" | "treta" | "conversa_engracada"
|
export type Situation = "lag_ou_bug" | "jogada" | "falha_engracada" | "morte" | "susto" | "treta" | "conversa_engracada"
|
||||||
@@ -470,8 +493,15 @@ export const SOURCE_LABEL: Record<Clip["source"], string> = {
|
|||||||
chat: "pico do chat", audio: "pico do áudio", manual: "corte manual", ai: "IA viu na tela", face: "reação no rosto",
|
chat: "pico do chat", audio: "pico do áudio", manual: "corte manual", ai: "IA viu na tela", face: "reação no rosto",
|
||||||
};
|
};
|
||||||
|
|
||||||
export const FACE_LABEL: Record<FaceReaction["label"], string> = {
|
export const FACE_LABEL: Record<FaceExpression, string> = {
|
||||||
risada: "risada", grito: "grito", susto: "susto", choque: "choque", confuso: "confuso", raiva: "raiva", neutro: "neutro",
|
risada: "risada", grito: "grito", susto: "susto", choque: "choque", confuso: "confuso", raiva: "raiva", neutro: "neutro",
|
||||||
|
gargalhada: "gargalhada", alegria: "alegria", medo: "medo", espanto: "espanto", nojo: "nojo", tristeza: "tristeza",
|
||||||
|
tenso: "tensão", bocejo: "bocejo",
|
||||||
|
};
|
||||||
|
|
||||||
|
export const BODY_LABEL: Record<BodyLabel, string> = {
|
||||||
|
"balançando": "balançando a cabeça", acenando: "acenando com a cabeça", agitado: "agitado na cadeira",
|
||||||
|
"chegou perto": "chegou perto da câmera", "saiu do quadro": "saiu do quadro",
|
||||||
};
|
};
|
||||||
|
|
||||||
export const SITUATION_LABEL: Record<Situation, string> = {
|
export const SITUATION_LABEL: Record<Situation, string> = {
|
||||||
|
|||||||
@@ -10,6 +10,7 @@ import {
|
|||||||
} from "./clipper-clip-parts";
|
} from "./clipper-clip-parts";
|
||||||
import { isOther, speakerLabel } from "./clip-editor-model";
|
import { isOther, speakerLabel } from "./clip-editor-model";
|
||||||
import { Dialog } from "./dialog";
|
import { Dialog } from "./dialog";
|
||||||
|
import { FaceMap } from "./clipper-face-map";
|
||||||
import { ArrowLeftIcon, ArrowRightIcon, CheckIcon, ClockIcon } from "./icons";
|
import { ArrowLeftIcon, ArrowRightIcon, CheckIcon, ClockIcon } from "./icons";
|
||||||
import type { PublishJob } from "./publishing-client";
|
import type { PublishJob } from "./publishing-client";
|
||||||
import { PublishChips, TextLink } from "./publishing-ui";
|
import { PublishChips, TextLink } from "./publishing-ui";
|
||||||
@@ -102,6 +103,7 @@ function ClipBody({ clip, onChanged, publishJobs }: { clip: Clip; onChanged: ()
|
|||||||
<ClipVideoState clip={clip} show={show} onShow={setShow} pending={pending} run={run} />
|
<ClipVideoState clip={clip} show={show} onShow={setShow} pending={pending} run={run} />
|
||||||
<ChatSignals clip={clip} />
|
<ChatSignals clip={clip} />
|
||||||
<FaceSignal clip={clip} />
|
<FaceSignal clip={clip} />
|
||||||
|
<FaceMap clip={clip} />
|
||||||
</div>
|
</div>
|
||||||
|
|
||||||
<div className="grid min-w-0 content-start gap-5">
|
<div className="grid min-w-0 content-start gap-5">
|
||||||
|
|||||||
@@ -0,0 +1,102 @@
|
|||||||
|
"use client";
|
||||||
|
// Mapa de expressões de UM corte: uma faixa com a expressão dominante do streamer em cada segundo do trecho (cor por
|
||||||
|
// família) e, embaixo, o movimento do corpo (balançando, agitado, saiu do quadro…), que aparece mesmo quando o rosto
|
||||||
|
// está de perfil e não dá para ler expressão. Busca a série sozinho (GET sessions/{id}/face do trecho), ao contrário
|
||||||
|
// das peças de clipper-clip-parts. Serviço antigo (sem `expr`) ou corte sem câmera: não mostra nada.
|
||||||
|
import { useEffect, useState } from "react";
|
||||||
|
import {
|
||||||
|
BODY_LABEL, FACE_LABEL, clipperCall, formatClock,
|
||||||
|
type BodyLabel, type Clip, type FaceExpression, type FaceMapSecond, type FaceView,
|
||||||
|
} from "./clipper-client";
|
||||||
|
import { Spinner, cx } from "./ui";
|
||||||
|
|
||||||
|
/** Cor de cada expressão, por família: alegria (verde), susto/surpresa (amarelo), raiva/grito (vermelho), tristeza e
|
||||||
|
* tensão (azul), confusão (violeta); neutro e bocejo quase somem. */
|
||||||
|
const EXPR_TONE: Record<FaceExpression, string> = {
|
||||||
|
risada: "bg-success", gargalhada: "bg-success", alegria: "bg-success/45",
|
||||||
|
susto: "bg-warning", choque: "bg-warning/80", espanto: "bg-warning/60", medo: "bg-glow",
|
||||||
|
grito: "bg-flame", raiva: "bg-danger", nojo: "bg-option-d",
|
||||||
|
tristeza: "bg-info", tenso: "bg-option-b/70", confuso: "bg-option-c",
|
||||||
|
bocejo: "bg-fg-subtle/30", neutro: "bg-line-strong",
|
||||||
|
};
|
||||||
|
|
||||||
|
type Load = { state: "loading" } | { state: "error"; text: string } | { state: "ok"; view: FaceView };
|
||||||
|
|
||||||
|
export function FaceMap({ clip }: { clip: Clip }) {
|
||||||
|
const from = Math.floor(clip.startS);
|
||||||
|
const to = Math.ceil(clip.endS);
|
||||||
|
const [load, setLoad] = useState<Load>({ state: "loading" });
|
||||||
|
|
||||||
|
useEffect(() => {
|
||||||
|
let alive = true;
|
||||||
|
setLoad({ state: "loading" });
|
||||||
|
void clipperCall<FaceView>(`sessions/${clip.sessionId}/face?from=${from}&to=${to}`).then((r) => {
|
||||||
|
if (alive) setLoad(r.ok ? { state: "ok", view: r.data } : { state: "error", text: r.error });
|
||||||
|
});
|
||||||
|
return () => { alive = false; };
|
||||||
|
}, [clip.sessionId, from, to]);
|
||||||
|
|
||||||
|
if (load.state === "loading") {
|
||||||
|
return <p className="flex items-center gap-2 text-xs text-fg-subtle"><Spinner className="size-3.5" />Lendo o mapa de expressões…</p>;
|
||||||
|
}
|
||||||
|
if (load.state === "error") return null; // sem câmera, rastreio desligado ou serviço fora: o resto do modal segue
|
||||||
|
const seconds = load.view.seconds.filter((s) => s.t >= from && s.t < to);
|
||||||
|
const hasMap = seconds.some((s) => s.expr || s.body);
|
||||||
|
if (!seconds.length || !hasMap) return null;
|
||||||
|
|
||||||
|
const counts = new Map<FaceExpression, number>();
|
||||||
|
for (const s of seconds) if (s.expr && s.expr !== "neutro") counts.set(s.expr, (counts.get(s.expr) ?? 0) + 1);
|
||||||
|
const legend = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 6);
|
||||||
|
const bodies = (load.view.body ?? []).filter((b) => b.endS >= from && b.startS < to);
|
||||||
|
const withFace = seconds.filter((s) => s.expr).length;
|
||||||
|
const summary = [
|
||||||
|
legend.length ? `Expressões: ${legend.map(([k, n]) => `${FACE_LABEL[k] ?? k} ${n} s`).join(", ")}` : "Sem expressão marcante",
|
||||||
|
bodies.length ? `corpo: ${bodies.map((b) => `${BODY_LABEL[b.label] ?? b.label} em ${formatClock(b.peakS)}`).join(", ")}` : "",
|
||||||
|
].filter(Boolean).join("; ");
|
||||||
|
|
||||||
|
return (
|
||||||
|
<section aria-label="Mapa de expressões do corte" className="grid gap-1.5">
|
||||||
|
<h3 className="flex items-baseline justify-between gap-2 text-eyebrow font-semibold text-fg-subtle uppercase">
|
||||||
|
Mapa de expressões
|
||||||
|
<span className="font-normal normal-case tabular-nums">
|
||||||
|
{withFace < seconds.length ? `rosto legível em ${Math.round((100 * withFace) / seconds.length)}%` : `${seconds.length} s`}
|
||||||
|
</span>
|
||||||
|
</h3>
|
||||||
|
<div role="img" aria-label={summary} className="grid gap-0.5">
|
||||||
|
<Strip seconds={seconds} pick={(s) => (s.expr ? EXPR_TONE[s.expr] ?? "bg-line-strong" : "")}
|
||||||
|
title={(s) => `${formatClock(s.t)} · ${s.expr ? FACE_LABEL[s.expr] ?? s.expr : (s.head ?? 0) > 0 ? "rosto de perfil (sem expressão legível)" : "sem rosto"}`}
|
||||||
|
className="h-4" />
|
||||||
|
{bodies.length > 0 && (
|
||||||
|
<Strip seconds={seconds} pick={(s) => (s.body ? "bg-accent" : "")}
|
||||||
|
title={(s) => `${formatClock(s.t)} · ${s.body ? BODY_LABEL[s.body] ?? s.body : "corpo parado"}`} className="h-1.5" />
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
<ul className="flex flex-wrap gap-x-3 gap-y-1 text-[0.75rem] text-fg-muted">
|
||||||
|
{legend.map(([k, n]) => (
|
||||||
|
<li key={k} className="inline-flex items-center gap-1.5">
|
||||||
|
<span aria-hidden className={cx("size-2.5 rounded-sm", EXPR_TONE[k])} />{FACE_LABEL[k] ?? k}
|
||||||
|
<span className="text-fg-subtle tabular-nums">{n} s</span>
|
||||||
|
</li>
|
||||||
|
))}
|
||||||
|
{bodies.map((b) => (
|
||||||
|
<li key={`${b.label}-${b.startS}`} className="inline-flex items-center gap-1.5">
|
||||||
|
<span aria-hidden className="h-1.5 w-2.5 rounded-sm bg-accent" />{BODY_LABEL[b.label as BodyLabel] ?? b.label}
|
||||||
|
<span className="text-fg-subtle tabular-nums">{formatClock(b.peakS)}</span>
|
||||||
|
</li>
|
||||||
|
))}
|
||||||
|
{!legend.length && !bodies.length && <li className="text-fg-subtle">rosto neutro no trecho</li>}
|
||||||
|
</ul>
|
||||||
|
</section>
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Uma faixa: uma célula por segundo (cor de `pick`; vazio = sem dado), dica com `title` ao passar o mouse. */
|
||||||
|
function Strip({ seconds, pick, title, className }: {
|
||||||
|
seconds: FaceMapSecond[]; pick: (s: FaceMapSecond) => string; title: (s: FaceMapSecond) => string; className?: string;
|
||||||
|
}) {
|
||||||
|
return (
|
||||||
|
<div className={cx("flex overflow-hidden rounded-sm bg-sunken/60", className)}>
|
||||||
|
{seconds.map((s) => <span key={s.t} title={title(s)} className={cx("min-w-0 flex-1", pick(s))} />)}
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user