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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+514
View File
@@ -0,0 +1,514 @@
"""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