|
|
import argparse
|
|
|
import cv2
|
|
|
import numpy as np
|
|
|
from skimage.metrics import structural_similarity as ssim
|
|
|
import torch
|
|
|
import torchvision.models as models
|
|
|
import torchvision.transforms as transforms
|
|
|
from scipy.linalg import sqrtm
|
|
|
import os
|
|
|
import json
|
|
|
from datetime import datetime
|
|
|
|
|
|
|
|
|
def extract_frames(video_path, max_frames=100):
|
|
|
"""Extract frames from video, limiting maximum frames for efficiency"""
|
|
|
cap = cv2.VideoCapture(video_path)
|
|
|
frames = []
|
|
|
count = 0
|
|
|
while cap.isOpened() and count < max_frames:
|
|
|
ret, frame = cap.read()
|
|
|
if not ret:
|
|
|
break
|
|
|
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
|
|
|
frames.append(frame)
|
|
|
count += 1
|
|
|
cap.release()
|
|
|
return frames
|
|
|
|
|
|
|
|
|
def compute_ssim(input_frames, output_frames):
|
|
|
"""Calculate average SSIM between input and output frames"""
|
|
|
ssim_scores = []
|
|
|
for in_frame, out_frame in zip(input_frames, output_frames):
|
|
|
|
|
|
min_shape = (min(in_frame.shape[0], out_frame.shape[0]),
|
|
|
min(in_frame.shape[1], out_frame.shape[1]))
|
|
|
in_frame = cv2.resize(in_frame, min_shape[::-1])
|
|
|
out_frame = cv2.resize(out_frame, min_shape[::-1])
|
|
|
|
|
|
in_gray = cv2.cvtColor(in_frame, cv2.COLOR_RGB2GRAY)
|
|
|
out_gray = cv2.cvtColor(out_frame, cv2.COLOR_RGB2GRAY)
|
|
|
score = ssim(in_gray, out_gray, data_range=255)
|
|
|
ssim_scores.append(score)
|
|
|
return np.mean(ssim_scores) if ssim_scores else 0.0
|
|
|
|
|
|
|
|
|
def get_inception_features(frames, model, transform, device):
|
|
|
"""Extract Inception V3 features for FID calculation"""
|
|
|
features = []
|
|
|
for frame in frames:
|
|
|
img = cv2.resize(frame, (299, 299))
|
|
|
img = transform(img).unsqueeze(0).to(device)
|
|
|
with torch.no_grad():
|
|
|
feat = model(img).squeeze().cpu().numpy()
|
|
|
features.append(feat)
|
|
|
return np.array(features)
|
|
|
|
|
|
|
|
|
def compute_fid(input_frames, output_frames):
|
|
|
"""Calculate FID between input and output frames using Inception V3"""
|
|
|
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
|
|
inception = models.inception_v3(pretrained=True, transform_input=False).eval().to(device)
|
|
|
|
|
|
transform = transforms.Compose([
|
|
|
transforms.ToTensor(),
|
|
|
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
|
|
|
])
|
|
|
|
|
|
input_features = get_inception_features(input_frames, inception, transform, device)
|
|
|
output_features = get_inception_features(output_frames, inception, transform, device)
|
|
|
|
|
|
|
|
|
mu1, sigma1 = np.mean(input_features, axis=0), np.cov(input_features, rowvar=False)
|
|
|
mu2, sigma2 = np.mean(output_features, axis=0), np.cov(output_features, rowvar=False)
|
|
|
|
|
|
|
|
|
diff = mu1 - mu2
|
|
|
covmean = sqrtm(sigma1.dot(sigma2))
|
|
|
if np.iscomplexobj(covmean):
|
|
|
covmean = covmean.real
|
|
|
fid = diff.dot(diff) + np.trace(sigma1 + sigma2 - 2 * covmean)
|
|
|
return fid
|
|
|
|
|
|
|
|
|
def evaluate_animeganv3(input_video, output_video, ssim_threshold=0.7, fid_threshold=400):
|
|
|
"""Evaluate AnimeGANv3 stylization effect using SSIM and FID"""
|
|
|
messages = []
|
|
|
messages.append(f"Evaluating videos:\nInput video: {input_video}\nOutput video: {output_video}")
|
|
|
|
|
|
|
|
|
input_frames = extract_frames(input_video)
|
|
|
output_frames = extract_frames(output_video)
|
|
|
|
|
|
if len(input_frames) == 0 or len(output_frames) == 0:
|
|
|
messages.append("Error: Failed to extract frames from one or both videos.")
|
|
|
return False, "\n".join(messages)
|
|
|
|
|
|
if len(input_frames) != len(output_frames):
|
|
|
messages.append("Warning: Input and output videos have different frame counts.")
|
|
|
min_frames = min(len(input_frames), len(output_frames))
|
|
|
input_frames = input_frames[:min_frames]
|
|
|
output_frames = output_frames[:min_frames]
|
|
|
|
|
|
|
|
|
avg_ssim = compute_ssim(input_frames, output_frames)
|
|
|
messages.append(f"Average SSIM: {avg_ssim:.4f}")
|
|
|
|
|
|
|
|
|
fid_score = compute_fid(input_frames, output_frames)
|
|
|
messages.append(f"FID score: {fid_score:.2f}")
|
|
|
|
|
|
|
|
|
ssim_pass = avg_ssim >= ssim_threshold
|
|
|
fid_pass = fid_score <= fid_threshold
|
|
|
success = ssim_pass and fid_pass
|
|
|
|
|
|
result_message = f"\nEvaluation results:\n"
|
|
|
result_message += f"SSIM (≥ {ssim_threshold}): {'Pass' if ssim_pass else 'Fail'} ({avg_ssim:.4f})\n"
|
|
|
result_message += f"FID (≤ {fid_threshold}): {'Pass' if fid_pass else 'Fail'} ({fid_score:.2f})\n"
|
|
|
result_message += f"Overall success: {'Yes' if success else 'No'}"
|
|
|
messages.append(result_message)
|
|
|
|
|
|
return success, "\n".join(messages)
|
|
|
|
|
|
|
|
|
def is_valid_video_file(file_path):
|
|
|
"""Check if file exists, is non-empty and has valid video format (.mp4)"""
|
|
|
if not os.path.exists(file_path):
|
|
|
return False, f"File {file_path} does not exist."
|
|
|
if os.path.getsize(file_path) == 0:
|
|
|
return False, f"File {file_path} is empty."
|
|
|
if not file_path.lower().endswith('.mp4'):
|
|
|
return False, f"File {file_path} has incorrect format, only .mp4 supported."
|
|
|
return True, ""
|
|
|
|
|
|
|
|
|
def main():
|
|
|
parser = argparse.ArgumentParser(description="Evaluate AnimeGANv3 video stylization effect")
|
|
|
parser.add_argument("-i", "--groundtruth", required=True, help="Input video file path")
|
|
|
parser.add_argument("-o", "--output", required=True, help="Output video file path")
|
|
|
parser.add_argument("--ssim_threshold", type=float, default=0.7, help="SSIM success threshold")
|
|
|
parser.add_argument("--fid_threshold", type=float, default=400.0, help="FID success threshold")
|
|
|
parser.add_argument("--result", help="JSONL file path to save results")
|
|
|
|
|
|
args = parser.parse_args()
|
|
|
|
|
|
|
|
|
messages = []
|
|
|
success = False
|
|
|
process_valid = True
|
|
|
|
|
|
|
|
|
input_valid, input_error = is_valid_video_file(args.groundtruth)
|
|
|
output_valid, output_error = is_valid_video_file(args.output)
|
|
|
|
|
|
if not input_valid:
|
|
|
messages.append(input_error)
|
|
|
process_valid = False
|
|
|
if not output_valid:
|
|
|
messages.append(output_error)
|
|
|
process_valid = False
|
|
|
|
|
|
|
|
|
if process_valid:
|
|
|
success, eval_message = evaluate_animeganv3(
|
|
|
args.groundtruth,
|
|
|
args.output,
|
|
|
args.ssim_threshold,
|
|
|
args.fid_threshold
|
|
|
)
|
|
|
messages.append(eval_message)
|
|
|
else:
|
|
|
messages.append("Evaluation not run due to input file validation failure.")
|
|
|
|
|
|
|
|
|
print("\n".join(messages))
|
|
|
|
|
|
|
|
|
|
|
|
if args.result:
|
|
|
result_entry = {
|
|
|
"Process": process_valid,
|
|
|
"Result": success,
|
|
|
"TimePoint": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
|
|
|
"comments": "\n".join(messages)
|
|
|
}
|
|
|
try:
|
|
|
os.makedirs(os.path.dirname(args.result) or '.', exist_ok=True)
|
|
|
with open(args.result, 'a', encoding='utf-8') as f:
|
|
|
json_line = json.dumps(result_entry, ensure_ascii=False, default=str)
|
|
|
f.write(json_line + '\n')
|
|
|
except Exception as e:
|
|
|
print(f"Error: Failed to save results to {args.result}, reason: {str(e)}")
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
main() |
