| import os |
| import logging |
| import yaml |
| import torch |
| import numpy as np |
| from scipy.optimize import linear_sum_assignment |
| from scipy.interpolate import interp1d |
| import cv2 |
| import glob |
| from pathlib import Path |
| from tqdm import tqdm |
| 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 fidelity.cotracker.predictor import CoTrackerPredictor |
| COTRACKER_AVAILABLE = True |
| except ImportError: |
| logger.warning("CoTracker not available. Please install cotracker package.") |
| COTRACKER_AVAILABLE = False |
|
|
|
|
| def load_metric_paths(path_yml='path.yml', metric_name='motion_fidelity'): |
| """Load checkpoint path from path.yml""" |
| try: |
| if not os.path.exists(path_yml): |
| logger.warning(f"Path configuration file not found: {path_yml}") |
| return 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 |
| |
| metric_config = paths_config[metric_name] |
| checkpoint_path = metric_config.get('checkpoint') |
| |
| logger.info(f"Loaded checkpoint path for {metric_name}: {checkpoint_path}") |
| |
| return checkpoint_path |
| |
| except Exception as e: |
| logger.error(f"Error loading metric paths from {path_yml}: {e}") |
| return None |
|
|
|
|
| class MotionFidelityEvaluator: |
| |
| def __init__(self, checkpoint_path, device="cuda", grid_size=10, max_frames=None): |
| self.device = device |
| self.checkpoint_path = checkpoint_path |
| self.grid_size = grid_size |
| self.max_frames = max_frames |
| self.model = None |
| |
| if not COTRACKER_AVAILABLE: |
| error_msg = "CoTracker not available. Please install cotracker package." |
| logger.error(error_msg) |
| raise ImportError(error_msg) |
| |
| self._load_model() |
| |
| def _load_model(self): |
| try: |
| logger.info("Loading CoTracker model...") |
| if self.checkpoint_path and os.path.exists(self.checkpoint_path): |
| logger.info(f"Loading CoTracker from checkpoint: {self.checkpoint_path}") |
| window_len = 60 |
| self.model = CoTrackerPredictor( |
| checkpoint=self.checkpoint_path, |
| v2=False, |
| offline=True, |
| window_len=window_len, |
| ) |
| else: |
| logger.info("Loading default CoTracker model from torch hub...") |
| self.model = torch.hub.load("facebookresearch/co-tracker", "cotracker3_offline") |
| |
| self.model = self.model.to(self.device) |
| logger.info("CoTracker model loaded successfully") |
| |
| except Exception as e: |
| error_msg = f"Failed to load CoTracker model: {e}" |
| logger.error(error_msg) |
| raise RuntimeError(error_msg) |
| |
| def read_frames_from_folder(self, folder_path, image_extensions=None): |
| if image_extensions is None: |
| image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif'] |
| |
| folder_path = Path(folder_path) |
| if not folder_path.exists(): |
| raise FileNotFoundError(f"Folder not found: {folder_path}") |
| |
| image_files = [] |
| for ext in image_extensions: |
| pattern = str(folder_path / f"*{ext}") |
| image_files.extend(glob.glob(pattern)) |
| pattern = str(folder_path / f"*{ext.upper()}") |
| image_files.extend(glob.glob(pattern)) |
| |
| if not image_files: |
| raise ValueError(f"No image files found in folder: {folder_path}") |
| |
| image_files.sort() |
| |
| if self.max_frames is not None: |
| image_files = image_files[:self.max_frames] |
| |
| logger.debug(f"Reading {len(image_files)} frames from {folder_path}") |
| |
| first_frame = cv2.imread(image_files[0]) |
| if first_frame is None: |
| raise ValueError(f"Cannot read image: {image_files[0]}") |
| |
| first_frame = cv2.cvtColor(first_frame, cv2.COLOR_BGR2RGB) |
| height, width = first_frame.shape[:2] |
| |
| frames = np.zeros((len(image_files), height, width, 3), dtype=np.uint8) |
| frames[0] = first_frame |
| |
| for i, image_file in enumerate(image_files[1:], 1): |
| frame = cv2.imread(image_file) |
| if frame is None: |
| logger.warning(f"Cannot read image {image_file}, skipping") |
| continue |
| |
| frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) |
| |
| if frame.shape[:2] != (height, width): |
| logger.debug(f"Resizing inconsistent frame {image_file}") |
| frame = cv2.resize(frame, (width, height)) |
| |
| frames[i] = frame |
| |
| return frames |
| |
| def read_video_file(self, video_path): |
| cap = cv2.VideoCapture(video_path) |
| if not cap.isOpened(): |
| raise ValueError(f"Cannot open video file: {video_path}") |
| |
| frames = [] |
| frame_count = 0 |
| |
| while True: |
| ret, frame = cap.read() |
| if not ret: |
| break |
| |
| frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) |
| frames.append(frame) |
| frame_count += 1 |
| |
| if self.max_frames is not None and frame_count >= self.max_frames: |
| break |
| |
| cap.release() |
| |
| if not frames: |
| raise ValueError(f"No frames extracted from video: {video_path}") |
| |
| return np.array(frames) |
| |
| def load_video_data(self, video_path): |
| video_path = Path(video_path) |
| |
| if video_path.is_file(): |
| frames = self.read_video_file(str(video_path)) |
| elif video_path.is_dir(): |
| frames = self.read_frames_from_folder(video_path) |
| else: |
| raise ValueError(f"Invalid path: {video_path}") |
| |
| video_tensor = torch.from_numpy(frames).permute(0, 3, 1, 2)[None].float() |
| return video_tensor |
| |
| def interpolate_track(self, track, visibility, target_length): |
| valid_indices = np.where(visibility > 0.5)[0] |
| |
| if len(valid_indices) < 2: |
| return np.zeros((target_length, 2)), np.zeros(target_length) |
| |
| valid_track = track[valid_indices] |
| |
| original_indices = np.linspace(0, 1, len(valid_indices)) |
| target_indices = np.linspace(0, 1, target_length) |
| |
| interp_x = interp1d(original_indices, valid_track[:, 0], kind='linear', |
| bounds_error=False, fill_value='extrapolate') |
| interp_y = interp1d(original_indices, valid_track[:, 1], kind='linear', |
| bounds_error=False, fill_value='extrapolate') |
| |
| interpolated_track = np.column_stack([interp_x(target_indices), interp_y(target_indices)]) |
| |
| interp_vis = interp1d(original_indices, np.ones(len(valid_indices)), kind='linear', |
| bounds_error=False, fill_value=0.5) |
| interpolated_visibility = interp_vis(target_indices) |
| |
| return interpolated_track, interpolated_visibility |
| |
| def compute_frame_by_frame_similarity(self, track1, track2, vis1, vis2): |
| T = len(track1) |
| |
| position_distances = np.linalg.norm(track1 - track2, axis=1) |
| |
| if T > 1: |
| velocity1 = np.diff(track1, axis=0) |
| velocity2 = np.diff(track2, axis=0) |
| velocity_distances = np.linalg.norm(velocity1 - velocity2, axis=1) |
| velocity_distances = np.concatenate([[velocity_distances[0]], velocity_distances]) |
| else: |
| velocity_distances = np.zeros(T) |
| |
| visibility_weights = np.minimum(vis1, vis2) |
| |
| track1_span = np.max(track1, axis=0) - np.min(track1, axis=0) |
| track2_span = np.max(track2, axis=0) - np.min(track2, axis=0) |
| normalization_factor = np.mean([np.linalg.norm(track1_span), np.linalg.norm(track2_span)]) |
| |
| if normalization_factor < 1e-6: |
| normalization_factor = 1.0 |
| |
| position_distances = position_distances / normalization_factor |
| velocity_distances = velocity_distances / normalization_factor |
| |
| position_similarities = 1.0 / (1.0 + position_distances) |
| velocity_similarities = 1.0 / (1.0 + velocity_distances) |
| |
| frame_similarities = (0.7 * position_similarities + 0.3 * velocity_similarities) |
| |
| weighted_similarities = frame_similarities * visibility_weights |
| |
| if np.sum(visibility_weights) > 0: |
| overall_similarity = np.sum(weighted_similarities) / np.sum(visibility_weights) |
| else: |
| overall_similarity = 0.0 |
| |
| return overall_similarity |
| |
| def synchronize_videos(self, tracks1, visibility1, tracks2, visibility2): |
| T1, N1 = tracks1.shape[:2] |
| T2, N2 = tracks2.shape[:2] |
| |
| target_length = min(T1, T2) |
| |
| synced_tracks1 = np.zeros((target_length, N1, 2)) |
| synced_vis1 = np.zeros((target_length, N1)) |
| synced_tracks2 = np.zeros((target_length, N2, 2)) |
| synced_vis2 = np.zeros((target_length, N2)) |
| |
| for i in range(N1): |
| synced_tracks1[:, i, :], synced_vis1[:, i] = self.interpolate_track( |
| tracks1[:, i, :], visibility1[:, i], target_length) |
| |
| for i in range(N2): |
| synced_tracks2[:, i, :], synced_vis2[:, i] = self.interpolate_track( |
| tracks2[:, i, :], visibility2[:, i], target_length) |
| |
| return synced_tracks1, synced_vis1, synced_tracks2, synced_vis2 |
| |
| def compute_motion_similarity(self, source_video_path, target_video_path): |
| if self.model is None: |
| raise RuntimeError("CoTracker model not loaded") |
| |
| video1 = self.load_video_data(source_video_path).to(self.device) |
| video2 = self.load_video_data(target_video_path).to(self.device) |
| |
| with torch.no_grad(): |
| pred_tracks1, pred_visibility1 = self.model( |
| video1, |
| grid_size=self.grid_size, |
| grid_query_frame=0, |
| backward_tracking=False, |
| ) |
| |
| pred_tracks2, pred_visibility2 = self.model( |
| video2, |
| grid_size=self.grid_size, |
| grid_query_frame=0, |
| backward_tracking=False, |
| ) |
| |
| similarity_score = self._compute_similarity_from_tracks( |
| pred_tracks1, pred_visibility1, pred_tracks2, pred_visibility2) |
| |
| return float(similarity_score) |
| |
| def _compute_similarity_from_tracks(self, tracks1, visibility1, tracks2, visibility2): |
| tracks1 = tracks1.squeeze(0).cpu().numpy() |
| tracks2 = tracks2.squeeze(0).cpu().numpy() |
| visibility1 = visibility1.squeeze(0).cpu().numpy() |
| visibility2 = visibility2.squeeze(0).cpu().numpy() |
| |
| tracks1, visibility1, tracks2, visibility2 = self.synchronize_videos( |
| tracks1, visibility1, tracks2, visibility2) |
| |
| min_track_length = 5 |
| min_visibility = 0.3 |
| |
| valid_indices1 = [] |
| valid_indices2 = [] |
| |
| for i in range(tracks1.shape[1]): |
| avg_vis = np.mean(visibility1[:, i]) |
| valid_frames = np.sum(visibility1[:, i] > 0.5) |
| if avg_vis > min_visibility and valid_frames >= min_track_length: |
| valid_indices1.append(i) |
| |
| for i in range(tracks2.shape[1]): |
| avg_vis = np.mean(visibility2[:, i]) |
| valid_frames = np.sum(visibility2[:, i] > 0.5) |
| if avg_vis > min_visibility and valid_frames >= min_track_length: |
| valid_indices2.append(i) |
| |
| if len(valid_indices1) == 0 or len(valid_indices2) == 0: |
| return 0.0 |
| |
| similarity_matrix = np.zeros((len(valid_indices1), len(valid_indices2))) |
| |
| for i, idx1 in enumerate(valid_indices1): |
| for j, idx2 in enumerate(valid_indices2): |
| track1 = tracks1[:, idx1, :] |
| track2 = tracks2[:, idx2, :] |
| vis1 = visibility1[:, idx1] |
| vis2 = visibility2[:, idx2] |
| |
| similarity = self.compute_frame_by_frame_similarity(track1, track2, vis1, vis2) |
| similarity_matrix[i, j] = similarity |
| |
| row_indices, col_indices = linear_sum_assignment(-similarity_matrix) |
| |
| similarity_threshold = 0.3 |
| valid_similarities = [] |
| |
| for i, j in zip(row_indices, col_indices): |
| similarity = similarity_matrix[i, j] |
| if similarity > similarity_threshold: |
| valid_similarities.append(similarity) |
| |
| if valid_similarities: |
| return np.mean(valid_similarities) |
| else: |
| return 0.0 |
|
|
|
|
| def motion_fidelity_single_video(evaluator, video_info, source_videos_path, target_videos_path, use_frames=True): |
| video_name = video_info['src_video_name'] |
| video_id = video_info['id'] |
| category = str(video_info.get("category", "")) |
| subcategory = str(video_info.get("subcategory", "")) |
|
|
| try: |
| if category in ["subject_motion_editing", "camera_motion_editing"] or subcategory == "event effect": |
| return { |
| 'video_id': int(video_id), |
| 'video_name': str(video_name), |
| 'video_results': -1.0, |
| 'category': category, |
| 'subcategory': subcategory |
| } |
|
|
| if use_frames: |
| video_name_without_ext = os.path.splitext(video_name)[0] |
| source_video_path = os.path.join(source_videos_path, video_name_without_ext) |
| target_video_path = os.path.join(target_videos_path, video_name_without_ext) |
| else: |
| source_video_path = os.path.join(source_videos_path, video_name) |
| target_video_path = os.path.join(target_videos_path, video_name) |
| |
| if not os.path.exists(source_video_path): |
| error_msg = f'Source path not found: {source_video_path}' |
| logger.warning(error_msg) |
| return { |
| 'video_id': int(video_id), |
| 'video_name': str(video_name), |
| 'video_results': -1.0, |
| 'category': category, |
| 'subcategory': subcategory, |
| 'error': error_msg |
| } |
| |
| if not os.path.exists(target_video_path): |
| error_msg = f'Target path not found: {target_video_path}' |
| logger.warning(error_msg) |
| return { |
| 'video_id': int(video_id), |
| 'video_name': str(video_name), |
| 'video_results': -1.0, |
| 'category': category, |
| 'subcategory': subcategory, |
| 'error': error_msg |
| } |
| |
| similarity = evaluator.compute_motion_similarity(source_video_path, target_video_path) |
| |
| return { |
| 'video_id': int(video_id), |
| 'video_name': str(video_name), |
| 'video_results': float(similarity), |
| 'category': category, |
| 'subcategory': 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': category, |
| 'subcategory': subcategory, |
| 'error': error_msg |
| } |
|
|
|
|
| def motion_fidelity_evaluation(video_info_list, source_videos_path, target_videos_path, |
| checkpoint_path, device="cuda", use_frames=True, grid_size=10, max_frames=None): |
| scores = [] |
| video_results = [] |
| |
| try: |
| evaluator = MotionFidelityEvaluator(checkpoint_path, device, grid_size, max_frames) |
| except Exception as e: |
| error_msg = f"Failed to initialize motion fidelity 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 fidelity evaluation") |
| |
| for video_info in tqdm(video_info_list, desc="Evaluating motion fidelity"): |
| result = motion_fidelity_single_video(evaluator, video_info, source_videos_path, target_videos_path, use_frames) |
| video_results.append(result) |
| |
| if 'error' not in result and result['video_results'] != -1.0: |
| scores.append(result['video_results']) |
| logger.debug(f"Video {result['video_name']}: motion fidelity score = {result['video_results']:.4f}") |
| else: |
| if 'error' in result: |
| logger.warning(f"Video {result['video_name']}: {result['error']}") |
| else: |
| logger.warning(f"Video {result['video_name']}: skipped (category/subcategory exclusion or processing failed)") |
| |
| if scores: |
| avg_score = sum(scores) / len(scores) |
| logger.info(f"Overall motion fidelity score: {avg_score:.4f} (based on {len(scores)}/{len(video_info_list)} valid videos)") |
| else: |
| avg_score = -1.0 |
| logger.error("No valid motion fidelity scores calculated") |
| |
| return float(avg_score), video_results |
|
|
| def compute_motion_fidelity(json_dir, device, source_videos_path=None, target_videos_path=None, |
| checkpoint_path=None, use_frames=True, grid_size=10, max_frames=None, |
| path_yml='path.yml', **kwargs): |
| """ |
| Compute motion fidelity metric using CoTracker |
| |
| 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 |
| target_videos_path: Path to target videos |
| checkpoint_path: Path to CoTracker checkpoint (if None, will load from path.yml) |
| use_frames: Whether to use frames or video files |
| grid_size: Grid size for CoTracker |
| max_frames: Maximum number of frames to process |
| path_yml: Path to the YAML file containing model paths |
| **kwargs: Additional arguments |
| |
| Returns: |
| tuple: (overall_score, video_results) |
| """ |
| try: |
| if not COTRACKER_AVAILABLE: |
| error_msg = "CoTracker not available. Please install cotracker package." |
| logger.error(error_msg) |
| return -1.0, [] |
|
|
| if checkpoint_path is None: |
| logger.info(f"Loading checkpoint path from {path_yml}") |
| checkpoint_path = load_metric_paths(path_yml, 'motion_fidelity') |
| |
| if checkpoint_path is None: |
| error_msg = "Checkpoint path must be provided either as argument or in path.yml" |
| logger.error(error_msg) |
| video_info_list = load_video_info(json_dir, 'motion_fidelity') |
| 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_fidelity') |
| logger.info(f"Loaded {len(video_info_list)} video entries") |
| |
| if source_videos_path is None: |
| raise ValueError("source_videos_path is required for motion fidelity evaluation") |
| |
| if target_videos_path is None: |
| raise ValueError("target_videos_path is required for motion fidelity evaluation") |
| |
| if not os.path.exists(source_videos_path): |
| raise FileNotFoundError(f"Source videos path not found: {source_videos_path}") |
| |
| if not os.path.exists(target_videos_path): |
| raise FileNotFoundError(f"Target videos path not found: {target_videos_path}") |
| |
| overall_score, video_results = motion_fidelity_evaluation( |
| video_info_list, source_videos_path, target_videos_path, |
| checkpoint_path, device, use_frames, grid_size, max_frames |
| ) |
| |
| if overall_score == -1.0: |
| logger.error("Motion fidelity evaluation failed.") |
| else: |
| logger.info(f"Motion fidelity evaluation completed. Overall score: {overall_score:.4f}") |
| |
| return overall_score, video_results |
| |
| except Exception as e: |
| error_msg = f"Error in compute_motion_fidelity: {str(e)}" |
| logger.error(error_msg) |
| return -1.0, [] |
