import os import cv2 import glob import torch import numpy as np import logging import yaml from tqdm import tqdm from omegaconf import OmegaConf from ivebench_utils import load_video_info logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) try: from quality.amt.utils.utils import ( img2tensor, tensor2img, check_dim_and_resize ) from quality.amt.utils.build_utils import build_from_cfg from quality.amt.utils.utils import InputPadder AMT_AVAILABLE = True except ImportError as e: logger.error(f"AMT modules not available: {e}") AMT_AVAILABLE = False def load_metric_paths(path_yml='path.yml', metric_name='motion_smoothness'): """Load config and checkpoint paths from path.yml""" try: if not os.path.exists(path_yml): logger.warning(f"Path configuration file not found: {path_yml}") return None, None with open(path_yml, 'r', encoding='utf-8') as f: paths_config = yaml.safe_load(f) if metric_name not in paths_config: logger.warning(f"Metric '{metric_name}' not found in {path_yml}") return None, None metric_config = paths_config[metric_name] config_path = metric_config.get('config') checkpoint_path = metric_config.get('checkpoint') logger.info(f"Loaded paths for {metric_name}:") logger.info(f" Config: {config_path}") logger.info(f" Checkpoint: {checkpoint_path}") return config_path, checkpoint_path except Exception as e: logger.error(f"Error loading metric paths from {path_yml}: {e}") return None, None class FrameProcess: def __init__(self): pass def get_frames(self, video_path): frame_list = [] video = cv2.VideoCapture(video_path) while video.isOpened(): success, frame = video.read() if success: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_list.append(frame) else: break video.release() assert frame_list != [], f"No frames extracted from {video_path}" return frame_list def get_frames_from_img_folder(self, img_folder): exts = ['jpg', 'png', 'jpeg', 'bmp', 'tif', 'tiff', 'JPG', 'PNG', 'JPEG', 'BMP', 'TIF', 'TIFF'] frame_list = [] imgs = sorted([p for p in glob.glob(os.path.join(img_folder, "*")) if os.path.splitext(p)[1][1:] in exts]) for img in imgs: frame = cv2.imread(img, cv2.IMREAD_COLOR) if frame is not None: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_list.append(frame) assert frame_list != [], f"No frames found in {img_folder}" return frame_list def extract_frame(self, frame_list, start_from=0): extract = [] for i in range(start_from, len(frame_list), 2): extract.append(frame_list[i]) return extract class MotionSmoothness: def __init__(self, config=None, ckpt=None, device="cuda"): self.device = device self.config = config self.ckpt = ckpt self.niters = 1 self.model = None self.initialization() if not AMT_AVAILABLE: error_msg = "AMT modules are not available. Cannot initialize motion smoothness evaluator." logger.error(error_msg) raise RuntimeError(error_msg) if not config or not ckpt: error_msg = "Config and checkpoint paths are required for AMT model." logger.error(error_msg) raise ValueError(error_msg) self.load_model() def load_model(self): try: cfg_path = self.config ckpt_path = self.ckpt if not os.path.exists(cfg_path): raise FileNotFoundError(f"Config file not found: {cfg_path}") if not os.path.exists(ckpt_path): raise FileNotFoundError(f"Checkpoint file not found: {ckpt_path}") network_cfg = OmegaConf.load(cfg_path).network network_name = network_cfg.name logger.info(f'Loading [{network_name}] from [{ckpt_path}]...') self.model = build_from_cfg(network_cfg) ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False) self.model.load_state_dict(ckpt['state_dict']) self.model = self.model.to(self.device) self.model.eval() logger.info("AMT model loaded successfully") except Exception as e: error_msg = f"Failed to load AMT model: {e}" logger.error(error_msg) raise RuntimeError(error_msg) def initialization(self): if self.device == 'cuda' and torch.cuda.is_available(): self.anchor_resolution = 1024 * 512 self.anchor_memory = 1500 * 1024**2 self.anchor_memory_bias = 2500 * 1024**2 self.vram_avail = torch.cuda.get_device_properties(0).total_memory logger.info("VRAM available: {:.1f} MB".format(self.vram_avail / 1024 ** 2)) else: self.anchor_resolution = 8192*8192 self.anchor_memory = 1 self.anchor_memory_bias = 0 self.vram_avail = 1 if torch.cuda.is_available(): self.embt = torch.tensor(1/2).float().view(1, 1, 1, 1).to(self.device) else: self.embt = torch.tensor(1/2).float().view(1, 1, 1, 1) self.fp = FrameProcess() def motion_score(self, video_path): if self.model is None: raise RuntimeError("AMT model is not loaded. Cannot compute motion score.") iters = int(self.niters) if video_path.endswith('.mp4'): frames = self.fp.get_frames(video_path) elif os.path.isdir(video_path): frames = self.fp.get_frames_from_img_folder(video_path) else: raise NotImplementedError(f"Unsupported input type: {video_path}") frame_list = self.fp.extract_frame(frames, start_from=0) inputs = [img2tensor(frame).to(self.device) for frame in frame_list] assert len(inputs) > 1, f"The number of input should be more than one (current {len(inputs)})" inputs = check_dim_and_resize(inputs) h, w = inputs[0].shape[-2:] scale = self.anchor_resolution / (h * w) * np.sqrt((self.vram_avail - self.anchor_memory_bias) / self.anchor_memory) scale = 1 if scale > 1 else scale scale = 1 / np.floor(1 / np.sqrt(scale) * 16) * 16 if scale < 1: logger.debug(f"Due to the limited VRAM, the video will be scaled by {scale:.2f}") padding = int(16 / scale) padder = InputPadder(inputs[0].shape, padding) inputs = padder.pad(*inputs) for i in range(iters): outputs = [inputs[0]] for in_0, in_1 in zip(inputs[:-1], inputs[1:]): in_0 = in_0.to(self.device) in_1 = in_1.to(self.device) with torch.no_grad(): imgt_pred = self.model(in_0, in_1, self.embt, scale_factor=scale, eval=True)['imgt_pred'] outputs += [imgt_pred.cpu(), in_1.cpu()] inputs = outputs outputs = padder.unpad(*outputs) outputs = [tensor2img(out) for out in outputs] vfi_score = self.vfi_score(frames, outputs) norm = (255.0 - vfi_score) / 255.0 return float(norm) def vfi_score(self, ori_frames, interpolate_frames): ori = self.fp.extract_frame(ori_frames, start_from=1) interpolate = self.fp.extract_frame(interpolate_frames, start_from=1) scores = [] for i in range(len(interpolate)): scores.append(self.get_diff(ori[i], interpolate[i])) return np.mean(np.array(scores)) def get_diff(self, img1, img2): img = cv2.absdiff(img1, img2) return np.mean(img) def motion_smoothness_single_video(motion_evaluator, video_info, target_videos_path, use_frames=True): video_name = video_info['src_video_name'] video_id = video_info['id'] try: if use_frames: video_name_without_ext = os.path.splitext(video_name)[0] target_frame_folder = os.path.join(target_videos_path, video_name_without_ext) video_path = target_frame_folder else: video_path = os.path.join(target_videos_path, video_name) if not os.path.exists(video_path): error_msg = f"Video path not found: {video_path}" logger.warning(error_msg) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']), 'error': error_msg } score = motion_evaluator.motion_score(video_path) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': float(score), 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']) } except Exception as e: error_msg = f"Error processing video {video_name}: {str(e)}" logger.error(error_msg) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg } def motion_smoothness_evaluation(video_info_list, target_videos_path, config=None, ckpt=None, device="cuda", use_frames=True): scores = [] video_results = [] try: motion_evaluator = MotionSmoothness(config, ckpt, device) except Exception as e: error_msg = f"Failed to initialize motion smoothness evaluator: {e}" logger.error(error_msg) for video_info in video_info_list: video_results.append({ 'video_id': int(video_info['id']), 'video_name': str(video_info['src_video_name']), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg }) return -1.0, video_results logger.info(f"Processing {len(video_info_list)} videos for motion smoothness evaluation") for video_info in tqdm(video_info_list, desc="Evaluating motion smoothness"): result = motion_smoothness_single_video(motion_evaluator, video_info, target_videos_path, use_frames) video_results.append(result) if 'error' not in result: scores.append(result['video_results']) logger.debug(f"Video {result['video_name']}: motion smoothness score = {result['video_results']:.4f}") else: logger.warning(f"Video {result['video_name']}: {result['error']}") if scores: avg_score = sum(scores) / len(scores) logger.info(f"Overall motion smoothness score: {avg_score:.4f} (based on {len(scores)}/{len(video_info_list)} valid videos)") else: avg_score = -1.0 logger.error("No valid motion smoothness scores calculated") return float(avg_score), video_results def compute_motion_smoothness(json_dir, device, source_videos_path=None, target_videos_path=None, config=None, ckpt=None, use_frames=True, path_yml='path.yml', **kwargs): """ Compute motion smoothness metric Args: json_dir: Path to JSON file with video information device: Device to run evaluation on ('cuda' or 'cpu') source_videos_path: Path to source videos (not used in this metric) target_videos_path: Path to target videos to evaluate config: Config file path (if None, will load from path.yml) ckpt: Checkpoint file path (if None, will load from path.yml) use_frames: Whether to use frames or video files path_yml: Path to the YAML file containing model paths **kwargs: Additional arguments Returns: tuple: (overall_score, video_results) """ try: if config is None or ckpt is None: logger.info(f"Loading model paths from {path_yml}") loaded_config, loaded_ckpt = load_metric_paths(path_yml, 'motion_smoothness') if config is None: config = loaded_config if ckpt is None: ckpt = loaded_ckpt if config is None or ckpt is None: error_msg = "Config and checkpoint paths must be provided either as arguments or in path.yml" logger.error(error_msg) video_info_list = load_video_info(json_dir, 'motion_smoothness') video_results = [] for video_info in video_info_list: video_results.append({ 'video_id': int(video_info['id']), 'video_name': str(video_info['src_video_name']), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg }) return -1.0, video_results video_info_list = load_video_info(json_dir, 'motion_smoothness') logger.info(f"Loaded {len(video_info_list)} video entries") if target_videos_path is None: raise ValueError("target_videos_path is required for motion smoothness evaluation") if not os.path.exists(target_videos_path): raise FileNotFoundError(f"Target videos path not found: {target_videos_path}") overall_score, video_results = motion_smoothness_evaluation( video_info_list, target_videos_path, config, ckpt, device, use_frames ) if overall_score == -1.0: logger.error("Motion smoothness evaluation failed.") else: logger.info(f"Motion smoothness evaluation completed. Overall score: {overall_score:.4f}") return overall_score, video_results except Exception as e: error_msg = f"Error in compute_motion_smoothness: {str(e)}" logger.error(error_msg) return -1.0, []