Files
CenaForge/clipper/app/reaction.py
T
MateuusandClaude Opus 5.5 84f30bbc2d CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 16:35:09 -03:00

515 lines
26 KiB
Python
Raw 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) com o início da reação, e um texto curto para o juiz;
- 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")
@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)
# --- 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…)
@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
def to_json(self) -> dict:
"""Formato compacto para o banco/API: 3 casas, sem os campos `None`."""
out: dict = {"t": self.t, "present": round(self.present, 3)}
for name in SECOND_FIELDS:
value = getattr(self, name)
if value is not None:
out[name] = round(value, 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})
@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 per_second(samples: list[FaceSample], duration_s: float, start_s: float = 0.0) -> 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.
"""
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))
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)
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)
return out
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))
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: risada, grito, susto, choque, confuso, raiva ou neutro.
Com `z` (de `channel_z`), um canal está "ligado" quando sobe acima do neutro do streamer; sem `z`, usa limiares
absolutos (`raw_thresholds`).
Regras (calibradas na live real, doc/FACE_BAKEOFF.md):
- **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**;
- **susto** = sobrancelha levantada ou olho arregalado + movimento da cabeça;
- **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).
"""
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}
else:
on = {name: (getattr(second, name) or 0.0) >= p.raw_thresholds[name] for name in SIGNAL_CHANNELS}
smiling_raw = second.smile >= p.smile_raw
if on["smile"] or (smiling_raw and (on["jaw"] or on["frown"] or on["brow"])):
return "risada"
if (on["surprise"] or on["brow"]) and on["motion"]:
return "susto"
if on["jaw"]:
return "grito"
if on["frown"]:
return "grito" if (second.jaw or 0.0) >= p.shout_jaw_raw else "raiva"
if on["surprise"]:
return "choque"
if on["brow"]:
return "confuso"
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]] = []
for peak in candidates:
name = _peak_label(seconds, zs, peak, p)
if name == "neutro" 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 _peak_label(seconds: list[FaceSecond], zs: list[dict[str, float] | None], peak: int, p: ReactionParams) -> str:
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)
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) -> 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.
"""
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]
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"
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}")
presence = len(with_face) / len(inside)
text = "; ".join(parts[:max_items]) if parts else "sem reação marcante no rosto"
if presence < 0.7:
text += f" (rosto visível em {int(round(presence * 100))}% do trecho)"
return text
# ---------------------------------------------------------------------------------------------------------------
# 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