Files
MateuusandClaude Opus 5.5 44f78bd483 Clipador: mapa de expressões do streamer (expressões novas, pose e corpo)
- Expressões novas dos blendshapes que já vinham do MediaPipe: gargalhada, alegria
  (no mapa), medo, espanto, nojo, tristeza, tensão e bocejo (que deixou de contar
  como grito); raiva também por olhos semicerrados + lábios apertados. Canais novos
  opcionais na série (brow_inner, mouth_frown, squint, press, stretch, upper_lip,
  pucker), z relativo ao neutro do próprio streamer só com os segundos que têm o campo.
- Pose da cabeça pela matriz de transformação facial (yaw/pitch/roll) e balanço/aceno
  por zigue-zague; YuNet nos quadros sem rosto dá a caixa da cabeça (streamer de perfil).
- Corpo mesmo sem expressão: balançando, acenando, agitado, chegou perto e saiu do
  quadro, sem contar rastreio perdido como movimento.
- API /face com expr/body por segundo e lista do corpo; linha do juiz com o corpo;
  painel com os rótulos novos e o "Mapa de expressões" no modal do corte.
- Calibrado nas sessões 7, 8, 11 e 15 (doc/clipador/EXPRESSOES.md); intensidade dos
  picos inalterada (canais novos só rotulam). Testes em tests/test_expressions.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 04:16:25 -03:00

976 lines
52 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Rastreio de reação do streamer: lógica pura (sem E/S, sem numpy/opencv/mediapipe).
Recebe o que o detector/rastreador já mediu (rosto por quadro com os blendshapes do MediaPipe, ou caixas de
rosto do YuNet) e transforma em:
- uma série por segundo (`FaceSecond`) compacta, para gravar no banco e para o editor reenquadrar a câmera;
- 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 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.
"""
from __future__ import annotations
import bisect
import math
import statistics
from dataclasses import dataclass, field, replace
# Canais com z (o piscar fica de fora: é ruído, não reação). `brow` = sobrancelha levantada (interna ou externa:
# na live real as duas sobem juntas); `surprise` = olho arregalado. `motion` só ajuda a ROTULAR (susto): fica fora da
# intensidade — na live real os maiores "picos" de movimento eram o rastreio perdendo o rosto, não reação.
SIGNAL_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow", "motion")
EXPRESSION_CHANNELS: tuple[str, ...] = ("smile", "jaw", "surprise", "frown", "brow")
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:
# --- série por segundo / sinal ---
min_present: float = 0.3 # fração mínima de quadros com rosto para o segundo contar
motion_min_present: float = 0.8 # movimento só vale com o rosto em ≥ 80 % do segundo (senão é o rastreio pulando)
baseline_s: int = 180 # janela do "neutro recente" do streamer
exclude_recent_s: int = 10 # os últimos segundos ficam fora do neutro (a própria reação não se anula)
min_baseline_n: int = 30 # menos segundos com rosto que isso na janela → usa todos os segundos com rosto da série
mad_floor: float = 0.05 # piso do desvio robusto de um canal sem piso próprio em `mad_floors`
# Pisos por canal, calibrados na live real (doc/FACE_BAKEOFF.md, sessão 3): no calmo o sorriso por segundo
# tem mediana ~0,10 e picos soltos de 0,38 (fala/tique) → piso 0,10; browInnerUp tem pico solto de 0,38 num
# segundo calmo contra 0,7–0,8 sustentado no lag → piso 0,10 e peso menor; browDown no calmo fica ≤ 0,07.
# `motion` em "tamanhos de rosto" por segundo.
mad_floors: dict[str, float] = field(default_factory=lambda: {
"smile": 0.10, "jaw": 0.05, "surprise": 0.06, "frown": 0.07, "brow": 0.10, "motion": 0.15,
})
weights: dict[str, float] = field(default_factory=lambda: {
"smile": 1.0, "jaw": 1.0, "surprise": 1.0, "frown": 0.8, "brow": 0.6, "motion": 0.7,
})
# --- picos ---
threshold: float = 3.0 # z mínimo do sinal para virar pico (igual ao `face_threshold` do plano)
strong_z: float = 6.0 # a partir daqui o texto diz "forte"
onset_z: float = 1.0 # o início/fim da reação é onde o sinal cai abaixo disto
max_onset_s: int = 10
min_gap_s: float = 4.0 # distância mínima entre dois picos
keep_neutral: bool = False # pico só de movimento (pegar a água, ajeitar a cadeira) vira "neutro" e sai
# --- rótulo ---
label_z: float = 2.0 # canal "ligado" no pico quando o z dele passa disto
smile_raw: float = 0.5 # sorriso alto em valor absoluto também conta (neutro sorridente saturado)
shout_jaw_raw: float = 0.2 # sobrancelha franzida COM boca aberta pelo menos isso = grito (senão, raiva)
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
# todo quadro; na lofigirl (sem webcam) a tela de um notebook desenhado, parada na borda, deu 0,61–0,66 em 8 de 12
# quadros e virou "câmera" de 24×34 px com o layout aplicado.
min_cam_score: float = 0.7
# Agrupa pelo CENTRO do grupo (média corrente) com tolerância em tamanhos de rosto: comparar com o 1º membro
# partiu o streamer em dois quando ele se inclinou (0,8 largura de rosto na bancada).
cluster_faces: float = 1.0 # distância máxima ao centro do grupo, em larguras (x) e alturas (y) de rosto
min_presence: float = 0.5 # grupo precisa aparecer em ≥ 50 % dos quadros
stable_faces: float = 0.6 # desvio-padrão máximo do centro do grupo, em tamanhos de rosto (bancada: 0,24)
full_frame_h: float = 0.4 # rosto mais alto que isso = câmera em tela cheia
expand_w: float = 3.2 # retângulo estimado = rosto × 3,2 na largura
expand_h: float = 3.6 # e × 3,6 na altura
shift_down: float = 0.45 # deslocado para baixo em "alturas de rosto" (ombros/peito aparecem na câmera)
edge_reach: float = 1.5 # borda da moldura vale se estiver até X larguras de rosto do lado estimado
headroom: float = 0.35 # a borda de cima nunca encosta no rosto: fica ≥ X alturas de rosto acima (testa/cabelo)
@dataclass(frozen=True)
class FaceSample:
"""Um quadro do rastreador. `cx`/`cy`/`size` normalizados (0..1) no recorte da câmera; `size` = altura do rosto."""
t: float
present: bool
cx: float = 0.0
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
class FaceSecond:
"""Resumo de um segundo. Canais `None` quando o rosto não apareceu nesse segundo."""
t: int
present: float = 0.0 # fração dos quadros com rosto
cx: float | None = None
cy: float | None = None
size: float | None = None
smile: float | None = None
jaw: float | None = None
surprise: float | None = None
frown: float | None = None
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 (graus e contagens: 1), sem os campos `None`."""
out: dict = {"t": self.t, "present": round(self.present, 3)}
for name in SECOND_FIELDS + EXTRA_SECOND_FIELDS:
value = getattr(self, name)
if value is not None:
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 + EXTRA_SECOND_FIELDS})
@dataclass
class ReactionMoment:
peak_s: int
onset_s: int # onde a reação começou (o que causou está logo antes)
end_s: int
intensity: float # z do sinal no pico
label: str
strong: bool
def to_json(self) -> dict:
return {"peakS": self.peak_s, "onsetS": self.onset_s, "endS": self.end_s,
"intensity": round(self.intensity, 2), "label": self.label, "strong": self.strong}
def seconds_to_json(seconds: list[FaceSecond]) -> list[dict]:
return [s.to_json() for s in seconds]
def seconds_from_json(data: list[dict]) -> list[FaceSecond]:
return [FaceSecond.from_json(d) for d in data]
# ---------------------------------------------------------------------------------------------------------------
# Série por segundo
def _mean(values: list[float]) -> float:
return sum(values) / len(values)
def _channels(blend: dict[str, float]) -> dict[str, float]:
"""Blendshapes do MediaPipe → canais de expressão (0..1).
Na live real (bancada) `eyeWide*` fica ~0 o tempo todo e `jawOpen` quase nunca passa de 0,1: a surpresa não
pode depender do olho arregalado: a sobrancelha levantada (`brow`, o maior entre a interna e a externa — na live
inteira as duas sobem juntas) é canal próprio e, com movimento da cabeça, já é susto. Marcou o lag: 0,27 de
média contra 0,02 no calmo.
"""
def g(name: str) -> float:
return float(blend.get(name, 0.0))
outer_up = (g("browOuterUpLeft") + g("browOuterUpRight")) / 2
return {
"smile": (g("mouthSmileLeft") + g("mouthSmileRight")) / 2,
"jaw": g("jawOpen"),
"surprise": (g("eyeWideLeft") + g("eyeWideRight")) / 2,
"frown": (g("browDownLeft") + g("browDownRight")) / 2,
"brow": max(g("browInnerUp"), outer_up),
"blink": (g("eyeBlinkLeft") + g("eyeBlinkRight")) / 2,
}
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)]
for sample in samples:
i = int(math.floor(sample.t)) - first
if 0 <= i < n:
buckets[i].append(sample)
out: list[FaceSecond] = []
previous: FaceSample | None = None # última amostra com rosto (para o movimento atravessar a virada do segundo)
for i, bucket in enumerate(buckets):
bucket.sort(key=lambda s: s.t)
second = FaceSecond(first + i, present=(sum(1 for s in bucket if s.present) / len(bucket)) if bucket else 0.0)
faces = [s for s in bucket if s.present and s.size > 0]
if faces:
channels = [_channels(s.blend) for s in faces]
second.cx = _mean([s.cx for s in faces])
second.cy = _mean([s.cy for s in faces])
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:
if previous is not None and s.t - previous.t <= 1.0:
scale = max(1e-6, (s.size + previous.size) / 2)
path += (math.hypot(s.cx - previous.cx, s.cy - previous.cy) + abs(s.size - previous.size)) / scale
previous = s
second.motion = path
out.append(second)
_body_fields(out, samples, first, p)
return out
# ---------------------------------------------------------------------------------------------------------------
# Sinal relativo ao neutro do streamer
def _has_face(second: FaceSecond, p: ReactionParams) -> bool:
return second.present >= p.min_present and second.smile is not None
def _robust(values: list[float], floor: float) -> tuple[float, float]:
"""Mediana e desvio robusto (1,4826 × MAD, com piso)."""
median = statistics.median(values)
mad = statistics.median([abs(v - median) for v in values])
return median, max(floor, 1.4826 * mad)
def channel_z(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[dict[str, float] | None]:
"""z robusto de cada canal por segundo contra o neutro recente do próprio streamer; `None` sem rosto."""
p = params or ReactionParams()
face_idx = [i for i, s in enumerate(seconds) if _has_face(s, p)]
# Série antiga (sem o canal) → 0: o canal fica parado em vez de quebrar.
values = {name: [getattr(seconds[i], name) or 0.0 for i in face_idx] for name in SIGNAL_CHANNELS}
floors = {name: p.mad_floors.get(name, p.mad_floor) for name in SIGNAL_CHANNELS}
# O neutro anda devagar: recalcula a cada `BASELINE_STEP_S` (com cache pelos limites da janela), e a janela sai
# por bisect em `face_idx` — antes era O(n²) e uma live de horas levava segundos por chamada.
cache: dict[tuple[int, int], dict[str, tuple[float, float]]] = {}
out: list[dict[str, float] | None] = []
for t, second in enumerate(seconds):
if not _has_face(second, p):
out.append(None)
continue
anchor = t - t % BASELINE_STEP_S
lo = bisect.bisect_left(face_idx, anchor - p.baseline_s)
hi = bisect.bisect_left(face_idx, anchor - p.exclude_recent_s)
if hi - lo < p.min_baseline_n:
# Começo da gravação: ainda não há neutro suficiente; usa a série inteira (a mediana aguenta os picos).
lo, hi = 0, len(face_idx)
base = cache.get((lo, hi))
if base is None:
base = cache[(lo, hi)] = {name: _robust(values[name][lo:hi], floors[name]) for name in SIGNAL_CHANNELS}
z: dict[str, float] = {}
for name in SIGNAL_CHANNELS:
median, spread = base[name]
z[name] = ((getattr(second, name) or 0.0) - median) / spread
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
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,
params: ReactionParams | None = None) -> list[float | None]:
"""Intensidade de reação por segundo (máximo ponderado dos z das expressões, ≥ 0); `None` sem rosto."""
p = params or ReactionParams()
if baseline_s is not None:
p = replace(p, baseline_s=baseline_s)
return [_signal_from_z(z, p) for z in channel_z(seconds, p)]
# ---------------------------------------------------------------------------------------------------------------
# Rótulo
def label(second: FaceSecond, z: dict[str, float] | None = None, params: ReactionParams | None = None) -> str:
"""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`, `extra_raw`).
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); 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);
- **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 + 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
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 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"
# ---------------------------------------------------------------------------------------------------------------
# Picos e resumo para o juiz
def reaction_moments(seconds: list[FaceSecond], params: ReactionParams | None = None) -> list[ReactionMoment]:
"""Picos do sinal (≥ `threshold`, do maior para o menor, a `min_gap_s` um do outro), em ordem de tempo.
A mesma reação num trecho contínuo acima de `onset_z` vira um pico só (risada de 5 s não conta duas vezes).
O rótulo vem do segundo do pico; se o pico for só movimento ("neutro"), olha os vizinhos (±1 s) — o grito pode
ter o máximo de boca um segundo antes do pulo. Sem rótulo de expressão o pico sai (salvo `keep_neutral`).
"""
p = params or ReactionParams()
zs = channel_z(seconds, p)
signal = [_signal_from_z(z, p) for z in zs]
values = [v if v is not None else -1.0 for v in signal]
# Trecho contínuo acima de `onset_z` de cada segundo: uma risada de 5 s é UM pico, não dois.
run = [0] * len(values)
current = 0
for i, v in enumerate(values):
if v >= p.onset_z and i > 0 and values[i - 1] >= p.onset_z:
run[i] = current
else:
current += 1
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, 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):
continue
chosen.append((peak, name))
moments: list[ReactionMoment] = []
for peak, name in sorted(chosen):
begin = peak
while begin > 0 and peak - begin < p.max_onset_s and values[begin - 1] >= p.onset_z:
begin -= 1
end = peak
while end + 1 < len(values) and end - peak < p.max_onset_s and values[end + 1] >= p.onset_z:
end += 1
moments.append(ReactionMoment(seconds[peak].t, seconds[begin].t, seconds[end].t, values[peak], name,
values[peak] >= p.strong_z))
return moments
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 = "bocejo" if yawns and j in yawns else label(seconds[j], zs[j], p)
if other != "neutro":
return other
return name
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,
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:
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:
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
def _rect(x: float, y: float, w: float, h: float) -> dict[str, float]:
return {"x": round(x, 4), "y": round(y, 4), "w": round(w, 4), "h": round(h, 4)}
def _clip_rect(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
x0, y0 = min(1.0, max(0.0, x0)), min(1.0, max(0.0, y0))
x1, y1 = min(1.0, max(0.0, x1)), min(1.0, max(0.0, y1))
return x0, y0, max(x0, x1), max(y0, y1)
def locate_cam(detections_per_frame: list[list[tuple[float, float, float, float, float]]], frame_w: float,
frame_h: float, edges: dict[str, list[float]] | None = None,
params: ReactionParams | None = None) -> dict:
"""Acha a câmera do streamer a partir das detecções de rosto de alguns quadros espalhados da live.
`detections_per_frame`: um item por quadro (lista vazia = nenhum rosto), cada detecção `(x, y, w, h, score)`
em pixels. `edges` (opcional): bordas persistentes da moldura da câmera, em fração do quadro —
`{"xs": [linhas verticais], "ys": [linhas horizontais]}` (ex.: média do gradiente entre os quadros).
A câmera é o grupo de rostos que aparece na mesma posição em ≥ `min_presence` dos quadros; rosto de jogo,
cutscene ou de outra pessoa passa por poucos quadros e é ignorado (na bancada, 6 rostos de uma tela de
carregamento apareceram em 2 de 12 quadros, sempre no mesmo lugar: é a presença que separa, não a posição).
Cada detecção entra no grupo cujo CENTRO (média corrente) esteja a até `cluster_faces` larguras/alturas de
rosto dela — o streamer que se inclina continua no mesmo grupo.
Retângulo: rosto expandido (≈3,2× largura, 3,6× altura, deslocado para baixo), com folga acima da testa.
Câmera sem moldura (streamer recortado sobre o jogo, o caso da bancada) só tem esse caminho; `edges` é opcional
e só ajusta os lados quando há moldura de verdade. Devolve
`{hasWebcam, cam: {x,y,w,h} | None, faceRect, confidence, fullFrame}` em frações 0..1.
"""
p = params or ReactionParams()
total = len(detections_per_frame)
empty = {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False}
if total == 0 or frame_w <= 0 or frame_h <= 0:
return empty
# Grupos por posição: cada um guarda (quadro, cx, cy, w, h, score) normalizados.
groups: list[list[tuple[int, float, float, float, float, float]]] = []
for frame, detections in enumerate(detections_per_frame):
for x, y, w, h, score in detections:
if score < p.min_score or w <= 0 or h <= 0:
continue
nw, nh = w / frame_w, h / frame_h
cx, cy = x / frame_w + nw / 2, y / frame_h + nh / 2
best, best_d = None, math.inf
for g in groups:
gx, gy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
dx, dy = abs(cx - gx) / gw, abs(cy - gy) / gh
if dx <= p.cluster_faces and dy <= p.cluster_faces and max(dx, dy) < best_d:
best, best_d = g, max(dx, dy)
if best is None:
groups.append([(frame, cx, cy, nw, nh, score)])
else:
best.append((frame, cx, cy, nw, nh, score))
candidates = []
for g in groups:
frames = len({d[0] for d in g})
ratio = frames / total
gw, gh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
# Estabilidade em tamanhos de rosto: independe do zoom da câmera e da resolução.
spread = math.hypot(statistics.pstdev([d[1] for d in g]) / gw, statistics.pstdev([d[2] for d in g]) / gh)
if ratio >= p.min_presence and spread <= p.stable_faces and _mean([d[5] for d in g]) >= p.min_cam_score:
candidates.append((ratio, _mean([d[5] for d in g]), spread, g))
if not candidates:
return empty
ratio, score, spread, g = max(candidates, key=lambda c: (c[0], c[1]))
fw, fh = _mean([d[3] for d in g]), _mean([d[4] for d in g])
fcx, fcy = _mean([d[1] for d in g]), _mean([d[2] for d in g])
face_rect = _rect(*_xywh(*_clip_rect(fcx - fw / 2, fcy - fh / 2, fcx + fw / 2, fcy + fh / 2)))
confidence = round(min(1.0, ratio * score * (1.0 - 0.5 * spread / p.stable_faces)), 3)
if fh > p.full_frame_h:
return {"hasWebcam": True, "cam": _rect(0, 0, 1, 1), "faceRect": face_rect,
"confidence": confidence, "fullFrame": True}
# Estimativa pelo rosto: 3,2× a largura, 3,6× a altura, deslocado para baixo (ombros aparecem na câmera).
cw, ch = fw * p.expand_w, fh * p.expand_h
ccy = fcy + p.shift_down * fh
x0, x1 = fcx - cw / 2, fcx + cw / 2
y0, y1 = ccy - ch / 2, ccy + ch / 2
if edges:
reach_x, reach_y = p.edge_reach * fw, p.edge_reach * fh
x0 = _snap(x0, edges.get("xs", []), outside_of=fcx - fw / 2, reach=reach_x, side=-1)
x1 = _snap(x1, edges.get("xs", []), outside_of=fcx + fw / 2, reach=reach_x, side=1)
# Em cima, a borda só vale acima da folga da testa: moldura falsa (ex.: um banner) não corta a cabeça.
y0 = _snap(y0, edges.get("ys", []), outside_of=fcy - fh / 2 - p.headroom * fh, reach=reach_y, side=-1)
y1 = _snap(y1, edges.get("ys", []), outside_of=fcy + fh / 2, reach=reach_y, side=1)
cam = _rect(*_xywh(*_clip_rect(x0, y0, x1, y1)))
return {"hasWebcam": True, "cam": cam, "faceRect": face_rect, "confidence": confidence, "fullFrame": False}
def _xywh(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float, float, float]:
return x0, y0, x1 - x0, y1 - y0
def _snap(estimate: float, lines: list[float], outside_of: float, reach: float, side: int) -> float:
"""Troca o lado estimado pela borda da moldura mais próxima dele, se houver uma além do rosto e a até `reach`."""
valid = [v for v in lines if (v <= outside_of if side < 0 else v >= outside_of) and abs(v - estimate) <= reach]
return min(valid, key=lambda v: abs(v - estimate)) if valid else estimate