Files
fakeface/DeepFake_Live.py
T
2026-10-26 14:02:04 +00:00

1157 lines
27 KiB
Python

import time
import threading
import traceback
import tkinter as tk
import cv2
import torch
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk
from src.config.inference_config import InferenceConfig
from src.live_portrait_wrapper import LivePortraitWrapper
from src.utils.camera import get_rotation_matrix
# ============================================================
# CONFIGURAÇÃO
# ============================================================
CAMERA_INDEX = 0
CAMERA_WIDTH = 640
CAMERA_HEIGHT = 480
DISPLAY_SIZE = 420
MODEL_SIZE = 256
# Preview da webcam ~25 FPS.
CAMERA_PREVIEW_MS = 40
# ============================================================
# APLICAÇÃO
# ============================================================
class DeepFakeLive:
def __init__(self, root):
self.root = root
self.root.title(
"LivePortrait — Demonstração Live de Conteúdo Sintético para o 4CFPQPE"
)
self.root.geometry("1450x850")
self.root.minsize(1150, 700)
# Webcam
self.cap = None
self.camera_running = False
self.last_frame = None
# Live
self.live_running = False
# LivePortrait
self.wrapper = None
# Source
self.source_path = None
self.source_original = None
self.source_photo = None
self.source_info = None
self.source_feature = None
self.source_kp = None
self.source_rotation = None
self.source_canonical_kp = None
# Primeiro frame da webcam
self.driving_first_info = None
self.driving_first_rotation = None
# Resultado
self.result_frame = None
# Performance
self.live_fps = 0.0
self.last_inference_time = 0.0
self.build_interface()
self.root.after(
200,
self.start_camera
)
# ========================================================
# INTERFACE
# ========================================================
def build_interface(self):
self.root.configure(
bg="#E5E7EB"
)
# ----------------------------------------------------
# HEADER
# ----------------------------------------------------
header = tk.Frame(
self.root,
bg="#111827",
height=100
)
header.pack(
fill="x"
)
tk.Label(
header,
text="LIVEPORTRAIT - CFPQP",
font=("Segoe UI", 28, "bold"),
bg="#111827",
fg="white"
).pack(
pady=(14, 0)
)
tk.Label(
header,
text="DEMONSTRAÇÃO LIVE — CFPQP",
font=("Segoe UI", 12, "bold"),
bg="#111827",
fg="#F59E0B"
).pack()
# ----------------------------------------------------
# ÁREA PRINCIPAL
# ----------------------------------------------------
main = tk.Frame(
self.root,
bg="#E5E7EB"
)
main.pack(
fill="both",
expand=True,
padx=20,
pady=20
)
for i in range(3):
main.columnconfigure(
i,
weight=1
)
main.rowconfigure(
1,
weight=1
)
titles = [
"1 — FOTOGRAFIA ORIGINAL",
"2 — WEBCAM / REAL STREAM",
"3 — DEEPFAKE LIVE"
]
for column, title in enumerate(titles):
tk.Label(
main,
text=title,
font=("Segoe UI", 12, "bold"),
bg="#E5E7EB",
fg="#111827"
).grid(
row=0,
column=column,
pady=5
)
# ----------------------------------------------------
# SOURCE
# ----------------------------------------------------
self.source_panel = tk.Label(
main,
text="Seleciona uma fotografia",
bg="#1F2937",
fg="white",
font=("Segoe UI", 14)
)
self.source_panel.grid(
row=1,
column=0,
sticky="nsew",
padx=5,
pady=5
)
# ----------------------------------------------------
# WEBCAM
# ----------------------------------------------------
self.camera_panel = tk.Label(
main,
text="A iniciar webcam...",
bg="black",
fg="white",
font=("Segoe UI", 14)
)
self.camera_panel.grid(
row=1,
column=1,
sticky="nsew",
padx=5,
pady=5
)
# ----------------------------------------------------
# RESULTADO
# ----------------------------------------------------
self.result_panel = tk.Label(
main,
text="LIVE ainda não iniciado",
bg="#111827",
fg="white",
font=("Segoe UI", 14)
)
self.result_panel.grid(
row=1,
column=2,
sticky="nsew",
padx=5,
pady=5
)
# ----------------------------------------------------
# CONTROLOS
# ----------------------------------------------------
controls = tk.Frame(
self.root,
bg="white"
)
controls.pack(
fill="x",
padx=20,
pady=(0, 10)
)
self.btn_photo = tk.Button(
controls,
text="FOTOGRAFIA",
command=self.select_source,
font=("Segoe UI", 11, "bold"),
padx=20,
pady=12
)
self.btn_photo.pack(
side="left",
padx=10,
pady=10
)
self.btn_start = tk.Button(
controls,
text="▶ INICIAR LIVE STREAM",
command=self.start_live,
font=("Segoe UI", 11, "bold"),
padx=25,
pady=12
)
self.btn_start.pack(
side="left",
padx=10
)
self.btn_stop = tk.Button(
controls,
text="■ PARAR",
command=self.stop_live,
font=("Segoe UI", 11, "bold"),
padx=25,
pady=12,
state="disabled"
)
self.btn_stop.pack(
side="left",
padx=10
)
self.performance_label = tk.Label(
controls,
text="FPS: -- | -- ms/frame | VRAM: -- GB",
font=("Consolas", 11, "bold"),
bg="white",
fg="#111827"
)
self.performance_label.pack(
side="right",
padx=25
)
# ----------------------------------------------------
# STATUS
# ----------------------------------------------------
self.status = tk.Label(
self.root,
text="Pronto.",
anchor="w",
bg="#111827",
fg="white",
font=("Consolas", 11),
padx=15,
pady=8
)
self.status.pack(
fill="x"
)
# ========================================================
# FOTOGRAFIA
# ========================================================
def select_source(self):
if self.live_running:
return
path = filedialog.askopenfilename(
title="Selecionar fotografia",
filetypes=[
(
"Imagens",
"*.jpg *.jpeg *.png *.webp"
),
(
"Todos os ficheiros",
"*.*"
)
]
)
if not path:
return
image_bgr = cv2.imread(
path
)
if image_bgr is None:
messagebox.showerror(
"Erro",
"Não foi possível abrir a fotografia."
)
return
self.source_path = path
self.source_original = image_bgr
rgb = cv2.cvtColor(
image_bgr,
cv2.COLOR_BGR2RGB
)
pil = Image.fromarray(
rgb
)
pil.thumbnail(
(
DISPLAY_SIZE,
500
)
)
self.source_photo = ImageTk.PhotoImage(
pil
)
self.source_panel.configure(
image=self.source_photo,
text=""
)
self.set_status(
"Fotografia selecionada. "
"Posiciona-te frontalmente na webcam."
)
# ========================================================
# WEBCAM
# ========================================================
def start_camera(self):
self.cap = cv2.VideoCapture(
CAMERA_INDEX,
cv2.CAP_DSHOW
)
if not self.cap.isOpened():
messagebox.showerror(
"Webcam",
"Não foi possível abrir a webcam."
)
return
self.cap.set(
cv2.CAP_PROP_FRAME_WIDTH,
CAMERA_WIDTH
)
self.cap.set(
cv2.CAP_PROP_FRAME_HEIGHT,
CAMERA_HEIGHT
)
self.cap.set(
cv2.CAP_PROP_BUFFERSIZE,
1
)
self.camera_running = True
self.update_camera()
def update_camera(self):
if not self.camera_running:
return
ret, frame = self.cap.read()
if ret:
self.last_frame = frame
# Apenas a visualização fica em espelho.
preview = cv2.flip(
frame,
1
)
rgb = cv2.cvtColor(
preview,
cv2.COLOR_BGR2RGB
)
pil = Image.fromarray(
rgb
)
pil.thumbnail(
(
DISPLAY_SIZE,
500
)
)
photo = ImageTk.PhotoImage(
pil
)
self.camera_panel.configure(
image=photo,
text=""
)
self.camera_panel.image = photo
self.root.after(
CAMERA_PREVIEW_MS,
self.update_camera
)
# ========================================================
# PREPARAR DRIVING FRAME
# ========================================================
def prepare_driving_frame(
self,
frame
):
h, w = frame.shape[:2]
size = min(
h,
w
)
x = (
w - size
) // 2
y = (
h - size
) // 2
crop = frame[
y:y + size,
x:x + size
]
crop = cv2.resize(
crop,
(
MODEL_SIZE,
MODEL_SIZE
),
interpolation=cv2.INTER_AREA
)
crop = cv2.cvtColor(
crop,
cv2.COLOR_BGR2RGB
)
return crop
# ========================================================
# PREPARAR SOURCE
# ========================================================
def prepare_source(self):
self.set_status_threadsafe(
"A preparar fotografia..."
)
image = self.source_original
h, w = image.shape[:2]
size = min(
h,
w
)
x = (
w - size
) // 2
y = (
h - size
) // 2
image = image[
y:y + size,
x:x + size
]
image = cv2.resize(
image,
(
MODEL_SIZE,
MODEL_SIZE
),
interpolation=cv2.INTER_AREA
)
image_rgb = cv2.cvtColor(
image,
cv2.COLOR_BGR2RGB
)
with torch.inference_mode():
I_s = self.wrapper.prepare_source(
image_rgb
)
self.source_info = (
self.wrapper.get_kp_info(
I_s
)
)
self.source_canonical_kp = (
self.source_info["kp"]
)
self.source_rotation = (
get_rotation_matrix(
self.source_info["pitch"],
self.source_info["yaw"],
self.source_info["roll"]
)
)
self.source_feature = (
self.wrapper.extract_feature_3d(
I_s
)
)
self.source_kp = (
self.wrapper.transform_keypoint(
self.source_info
)
)
# ========================================================
# INICIAR LIVE
# ========================================================
def start_live(self):
if self.source_original is None:
messagebox.showwarning(
"Fotografia",
"Seleciona primeiro uma fotografia."
)
return
if self.last_frame is None:
messagebox.showwarning(
"Webcam",
"Ainda não existe imagem da webcam."
)
return
self.btn_start.configure(
state="disabled"
)
self.btn_photo.configure(
state="disabled"
)
self.live_fps = 0.0
self.last_inference_time = 0.0
self.set_status(
"A carregar modelos LivePortrait..."
)
threading.Thread(
target=self.initialize_live,
daemon=True
).start()
def initialize_live(self):
try:
# -----------------------------------------------
# MODELOS SÃO CARREGADOS APENAS UMA VEZ
# -----------------------------------------------
if self.wrapper is None:
config = InferenceConfig()
self.wrapper = LivePortraitWrapper(
config
)
# -----------------------------------------------
# SOURCE
# -----------------------------------------------
self.prepare_source()
# -----------------------------------------------
# PRIMEIRO FRAME = REFERÊNCIA NEUTRA
# -----------------------------------------------
frame = self.last_frame.copy()
driving_rgb = (
self.prepare_driving_frame(
frame
)
)
with torch.inference_mode():
I_d = (
self.wrapper.prepare_source(
driving_rgb
)
)
self.driving_first_info = (
self.wrapper.get_kp_info(
I_d
)
)
self.driving_first_rotation = (
get_rotation_matrix(
self.driving_first_info["pitch"],
self.driving_first_info["yaw"],
self.driving_first_info["roll"]
)
)
self.live_running = True
self.root.after(
0,
self.live_started
)
self.live_loop()
except Exception as e:
traceback.print_exc()
self.live_running = False
self.root.after(
0,
lambda err=str(e):
messagebox.showerror(
"LivePortrait",
err
)
)
self.root.after(
0,
self.reset_buttons
)
def live_started(self):
self.btn_stop.configure(
state="normal"
)
self.set_status(
"LIVE ATIVO — move a cabeça, pisca os olhos, "
"sorri e fala."
)
# ========================================================
# LOOP LIVE
# ========================================================
def live_loop(self):
# ====================================================
# Toda esta secção é inferência.
# Não são construídos gradientes/autograd graphs.
# ====================================================
with torch.inference_mode():
while self.live_running:
if self.last_frame is None:
time.sleep(
0.005
)
continue
start = time.perf_counter()
try:
# ---------------------------------------
# DRIVING FRAME
# ---------------------------------------
frame = self.last_frame.copy()
driving_rgb = (
self.prepare_driving_frame(
frame
)
)
I_d = (
self.wrapper.prepare_source(
driving_rgb
)
)
# ---------------------------------------
# MOTION EXTRACTION
# ---------------------------------------
d_info = (
self.wrapper.get_kp_info(
I_d
)
)
R_d = get_rotation_matrix(
d_info["pitch"],
d_info["yaw"],
d_info["roll"]
)
# ---------------------------------------
# MOVIMENTO RELATIVO
# ---------------------------------------
R_new = (
R_d
@ self.driving_first_rotation.permute(
0,
2,
1
)
@ self.source_rotation
)
delta_new = (
self.source_info["exp"]
+
(
d_info["exp"]
-
self.driving_first_info["exp"]
)
)
scale_new = (
self.source_info["scale"]
*
(
d_info["scale"]
/
self.driving_first_info["scale"]
)
)
t_new = (
self.source_info["t"]
+
(
d_info["t"]
-
self.driving_first_info["t"]
)
)
t_new = (
t_new.clone()
)
t_new[
...,
2
].fill_(0)
# ---------------------------------------
# KEYPOINTS DO NOVO FRAME
# ---------------------------------------
x_d_new = (
scale_new
*
(
self.source_canonical_kp
@ R_new
+
delta_new
)
+
t_new
)
# ---------------------------------------
# STITCHING
# ---------------------------------------
x_d_new = (
self.wrapper.stitching(
self.source_kp,
x_d_new
)
)
# ---------------------------------------
# SYNTHESIS
# ---------------------------------------
output = (
self.wrapper.warp_decode(
self.source_feature,
self.source_kp,
x_d_new
)
)
result = (
self.wrapper.parse_output(
output["out"]
)[0]
)
# ---------------------------------------
# RESULTADO
# ---------------------------------------
self.result_frame = (
cv2.cvtColor(
result,
cv2.COLOR_RGB2BGR
)
)
# ---------------------------------------
# PERFORMANCE
# ---------------------------------------
elapsed = (
time.perf_counter()
-
start
)
if elapsed > 0:
current_fps = (
1.0
/
elapsed
)
if self.live_fps == 0:
self.live_fps = (
current_fps
)
else:
# Média exponencial para evitar
# FPS a saltar constantemente.
self.live_fps = (
self.live_fps
* 0.85
+
current_fps
* 0.15
)
self.last_inference_time = (
elapsed
* 1000.0
)
# ---------------------------------------
# INTERFACE
# ---------------------------------------
self.root.after(
0,
self.update_result_panel
)
except Exception:
traceback.print_exc()
self.live_running = False
self.root.after(
0,
lambda:
messagebox.showerror(
"LivePortrait",
"Erro durante o processamento LIVE.\n\n"
"Consulta o PowerShell para veres "
"o erro completo."
)
)
break
self.root.after(
0,
self.reset_buttons
)
# ========================================================
# RESULTADO
# ========================================================
def update_result_panel(self):
if self.result_frame is None:
return
frame = self.result_frame.copy()
# Mantemos o mesmo efeito de espelho da webcam.
frame = cv2.flip(
frame,
1
)
rgb = cv2.cvtColor(
frame,
cv2.COLOR_BGR2RGB
)
pil = Image.fromarray(
rgb
)
pil = pil.resize(
(
DISPLAY_SIZE,
DISPLAY_SIZE
),
Image.Resampling.LANCZOS
)
photo = ImageTk.PhotoImage(
pil
)
self.result_panel.configure(
image=photo,
text=""
)
self.result_panel.image = photo
# ----------------------------------------------------
# VRAM
# ----------------------------------------------------
if torch.cuda.is_available():
vram = (
torch.cuda.memory_allocated()
/
(1024 ** 3)
)
else:
vram = 0.0
# ----------------------------------------------------
# MÉTRICAS
# ----------------------------------------------------
self.performance_label.configure(
text=(
f"FPS: {self.live_fps:.1f}"
f" | "
f"{self.last_inference_time:.0f} ms/frame"
f" | "
f"VRAM: {vram:.1f} GB"
)
)
# ========================================================
# PARAR
# ========================================================
def stop_live(self):
self.live_running = False
self.set_status(
"A parar LIVE..."
)
def reset_buttons(self):
self.btn_start.configure(
state="normal"
)
self.btn_photo.configure(
state="normal"
)
self.btn_stop.configure(
state="disabled"
)
if not self.live_running:
self.set_status(
"LIVE parado."
)
# ========================================================
# STATUS
# ========================================================
def set_status(
self,
text
):
self.status.configure(
text=text
)
def set_status_threadsafe(
self,
text
):
self.root.after(
0,
lambda:
self.set_status(
text
)
)
def close(self):
self.live_running = False
self.camera_running = False
if self.cap is not None:
self.cap.release()
self.root.destroy()
if __name__ == "__main__":
root = tk.Tk()
app = DeepFakeLive(
root
)
root.protocol(
"WM_DELETE_WINDOW",
app.close
)
root.mainloop()