"""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