Merge branch 'clipper/expressions' into clipper/integ

This commit is contained in:
Mateuus
2026-11-18 04:19:30 -03:00
7 changed files with 1207 additions and 36 deletions
+65 -8
View File
@@ -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]
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:
"""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
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"
def __init__(self, model_path: Path):
def __init__(self, model_path: Path, detector: Detector | None = None):
try:
import mediapipe as mp
import numpy as np
@@ -193,8 +209,10 @@ class MediaPipeTracker:
min_face_presence_confidence=0.5,
min_tracking_confidence=0.5,
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._detector = detector
self._last_ms = -1
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))
result = self._lm.detect_for_video(image, ms)
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]]
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 {}
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:
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"]
if s.size is not None:
s.size = s.size * crop["h"]
if s.hsize is not None:
s.hsize = s.hsize * crop["h"]
return seconds
@@ -538,7 +577,7 @@ class FaceService:
if backend == OpenSeeFaceTracker.name:
return OpenSeeFaceTracker(self.store.path("osf_landmarks"), self.store.path("osf_detector"))
try:
return MediaPipeTracker(self.store.path("face_landmarker"))
return MediaPipeTracker(self.store.path("face_landmarker"), self._head_detector())
except FaceUnavailable as first:
if backend == MediaPipeTracker.name:
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
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:
"""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",
@@ -680,7 +728,7 @@ class FaceService:
self._save(sid, idx, "error", {"cam": cam}, msg)
return "error"
# 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),
"ms": int((time.perf_counter() - started) * 1000), "coords": "frame",
"seconds": reaction.seconds_to_json(seconds)}
@@ -779,7 +827,8 @@ class FaceService:
return ""
seconds = self.dense(session["id"], max(0.0, lo - BASELINE_EXTRA_S), 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 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)
signal = reaction.reaction_signal(seconds, params=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(
"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"]
rows = []
for s, z in zip(seconds, signal):
for s, z, mapped in zip(seconds, signal, expressions):
if s.t < start:
continue
item = s.to_json()
if z is not None:
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)
return {
"sessionId": sid, "enabled": self.enabled, "fps": FPS, "coords": "frame",
@@ -812,6 +868,7 @@ class FaceService:
"fromS": start, "toS": end,
"seconds": rows,
"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)
+487 -26
View File
@@ -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
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;
- 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.
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)
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)
class ReactionParams:
@@ -62,6 +94,42 @@ class ReactionParams:
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,
}) # 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) ---
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
@@ -91,6 +159,9 @@ class FaceSample:
cy: float = 0.0
size: float = 0.0
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
@@ -109,20 +180,37 @@ class FaceSecond:
brow: float | None = None
blink: 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:
"""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)}
for name in SECOND_FIELDS:
for name in SECOND_FIELDS + EXTRA_SECOND_FIELDS:
value = getattr(self, name)
if value is not None:
out[name] = round(value, 3)
out[name] = round(value, 1 if name in _ONE_DECIMAL else 3)
return out
@classmethod
def from_json(cls, data: dict) -> FaceSecond:
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
@@ -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).
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
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)))
first = int(math.floor(start_s))
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])
for name in ("smile", "jaw", "surprise", "frown", "brow"):
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])
path = 0.0
for s in faces:
@@ -213,6 +394,7 @@ def per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.
previous = s
second.motion = path
out.append(second)
_body_fields(out, samples, first, p)
return out
@@ -262,13 +444,71 @@ def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -
if second.present < p.motion_min_present:
z["motion"] = 0.0
out.append(z)
_extra_z(seconds, face_idx, out, p)
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:
if z is 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,
@@ -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:
"""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
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,
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);
- **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**;
streamer que já sorri o tempo todo o sorriso não tem para onde subir); com a cabeça jogada para trás =
**gargalhada**;
- **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;
- **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()
if second.smile is None:
return "neutro"
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:
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
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
return "risada"
jaw = second.jaw or 0.0
# 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"]:
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"]:
return "grito"
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"]:
return "choque"
if on["brow"]:
return "confuso"
if on["press"] and on["squint"]:
return "tenso"
return "neutro"
@@ -351,9 +624,10 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
run[i] = current
candidates = sorted((i for i, v in enumerate(values) if v >= p.threshold), key=lambda i: -values[i])
chosen: list[tuple[int, str]] = []
yawns = yawn_seconds(seconds, zs, p)
for peak in candidates:
name = _peak_label(seconds, zs, peak, p)
if name == "neutro" and not p.keep_neutral:
name = _peak_label(seconds, zs, peak, p, yawns)
if name in NOT_REACTION and not p.keep_neutral:
continue
# 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):
@@ -372,12 +646,32 @@ def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None =
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)
if name == "neutro":
for j in (peak - 1, peak + 1):
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":
return other
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,
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.
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`
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.
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()
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]
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)]
if not with_face:
return "rosto do streamer não aparece no trecho"
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"
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 = []
for m in (moments if moments is not None else reaction_moments(seconds, p)):
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}")
parts.append(f"{m.label}{' forte' if m.strong else ''} em {when(m.peak_s)}")
presence = len(with_face) / len(inside)
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:
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
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