benchmarks/edit/code/IVEBench/metrics/compliance/quantity_accuracy.py

import os
import re
import logging
import yaml
import torch
import numpy as np
from PIL import Image
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:
    import compliance.groundingdino.datasets.transforms as T
    from compliance.groundingdino.models import build_model
    from compliance.groundingdino.util.slconfig import SLConfig
    from compliance.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
    from compliance.groundingdino.util.vl_utils import create_positive_map_from_span
    GROUNDING_DINO_AVAILABLE = True
except ImportError:
    logger.warning("GroundingDINO not available. Please install groundingdino package.")
    GROUNDING_DINO_AVAILABLE = False

temp_dir = "./tmp/quantity_accuracy_frames"


def load_metric_paths(path_yml='path.yml', metric_name='quantity_accuracy'):
    """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_file = metric_config.get('config')
        checkpoint_path = metric_config.get('checkpoint')
        
        logger.info(f"Loaded paths for {metric_name}: config={config_file}, checkpoint={checkpoint_path}")
        
        return config_file, checkpoint_path
        
    except Exception as e:
        logger.error(f"Error loading metric paths from {path_yml}: {e}")
        return None, None


class QuantityAccuracyEvaluator:
    def __init__(self, config_file, checkpoint_path, device="cuda", box_threshold=0.3, text_threshold=0.25):
        self.config_file = config_file
        self.checkpoint_path = checkpoint_path
        self.device = device if torch.cuda.is_available() and device == "cuda" else "cpu"
        self.box_threshold = box_threshold
        self.text_threshold = text_threshold
        self.model = None
        
        self.image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif']
        
        if not GROUNDING_DINO_AVAILABLE:
            error_msg = "GroundingDINO not available. Please install groundingdino package."
            logger.error(error_msg)
            raise ImportError(error_msg)
        
        self._load_model()
    
    def _load_model(self):
        try:
            logger.info("Loading GroundingDINO model...")
            
            if not os.path.exists(self.config_file):
                raise FileNotFoundError(f"Config file not found: {self.config_file}")
            
            if not os.path.exists(self.checkpoint_path):
                raise FileNotFoundError(f"Checkpoint file not found: {self.checkpoint_path}")
            
            args = SLConfig.fromfile(self.config_file)
            args.device = self.device
            self.model = build_model(args)
            
            checkpoint = torch.load(self.checkpoint_path, map_location="cpu")
            load_res = self.model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False)
            logger.debug(f"Model load result: {load_res}")
            
            self.model = self.model.to(self.device)
            self.model.eval()
            
            logger.info("GroundingDINO model loaded successfully")
            
        except Exception as e:
            error_msg = f"Failed to load GroundingDINO model: {e}"
            logger.error(error_msg)
            raise RuntimeError(error_msg)
    
    def parse_edit_prompt(self, edit_prompt):
        if not edit_prompt:
            return None, None
        
        patterns = [
            r"increase\s+the\s+number\s+of\s+([\w\s]+?)\s+to\s+(\d+)",
            r"decrease\s+the\s+number\s+of\s+([\w\s]+?)\s+to\s+(\d+)",
            r"change\s+the\s+number\s+of\s+([\w\s]+?)\s+to\s+(\d+)",
            r"set\s+the\s+number\s+of\s+([\w\s]+?)\s+to\s+(\d+)",
            r"make\s+(\d+)\s+([\w\s]+?)",
            r"add\s+([\w\s]+?)\s+to\s+(\d+)",
            r"remove\s+([\w\s]+?)\s+to\s+(\d+)",
        ]
        
        patterns = [re.compile(p, re.IGNORECASE) for p in patterns]
        
        edit_prompt_lower = edit_prompt.lower().strip()
        
        for pattern in patterns:
            match = re.search(pattern, edit_prompt_lower)
            if match:
                object_name = match.group(1)
                target_count = int(match.group(2))
                
                if object_name.endswith('s') and target_count == 1:
                    if object_name.endswith('ies'):
                        object_name = object_name[:-3] + 'y'
                    elif object_name.endswith('es'):
                        object_name = object_name[:-2]
                    else:
                        object_name = object_name[:-1]
                elif not object_name.endswith('s') and target_count > 1:
                    if object_name.endswith('y'):
                        object_name = object_name[:-1] + 'ies'
                    elif object_name.endswith(('s', 'sh', 'ch', 'x', 'z')):
                        object_name = object_name + 'es'
                    else:
                        object_name = object_name + 's'
                
                return target_count, object_name
        
        logger.warning(f"Could not parse edit prompt: {edit_prompt}")
        return None, None
    
    def load_image(self, image_path):
        try:
            image_pil = Image.open(image_path).convert("RGB")
            
            transform = T.Compose([
                T.RandomResize([800], max_size=1333),
                T.ToTensor(),
                T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
            ])
            
            image, _ = transform(image_pil, None)
            return image_pil, image
            
        except Exception as e:
            logger.error(f"Failed to load image {image_path}: {e}")
            return None, None
    
    def get_grounding_output(self, image, caption):
        if self.model is None:
            raise RuntimeError("GroundingDINO model not loaded")
        
        caption = caption.lower().strip()
        if not caption.endswith("."):
            caption = caption + "."
        
        image = image.to(self.device)
        
        with torch.no_grad():
            outputs = self.model(image[None], captions=[caption])
        
        logits = outputs["pred_logits"].sigmoid()[0] 
        boxes = outputs["pred_boxes"][0]  
        
        logits_filt = logits.cpu().clone()
        boxes_filt = boxes.cpu().clone()
        filt_mask = logits_filt.max(dim=1)[0] > self.box_threshold
        logits_filt = logits_filt[filt_mask]
        boxes_filt = boxes_filt[filt_mask]
        
        tokenizer = self.model.tokenizer
        tokenized = tokenizer(caption)
        
        pred_phrases = []
        for logit in logits_filt:
            pred_phrase = get_phrases_from_posmap(logit > self.text_threshold, tokenized, tokenizer)
            pred_phrases.append(pred_phrase)
        
        return boxes_filt, pred_phrases
    
    def count_objects_in_frames(self, video_path, object_name, sample_frames=5):
        if self.model is None:
            raise RuntimeError("GroundingDINO model not loaded")
        
        frames = self._get_video_frames(video_path, sample_frames)
        if not frames:
            return 0.0, []
        
        frame_counts = []
        
        for frame_path in frames:
            image_pil, image = self.load_image(frame_path)
            if image is None:
                continue
            
            detection_text = f"a {object_name}"
            
            boxes, phrases = self.get_grounding_output(image, detection_text)
            
            count = len([phrase for phrase in phrases if object_name.lower() in phrase.lower()])
            frame_counts.append(count)
            
            logger.debug(f"Frame {frame_path}: detected {count} {object_name}(s)")
        
        if frame_counts:
            average_count = np.mean(frame_counts)
        else:
            average_count = 0.0
        
        return float(average_count), frame_counts
    
    def _get_video_frames(self, video_path, sample_frames=5):
        video_path = Path(video_path)
        
        if video_path.is_dir():
            image_files = []
            for ext in self.image_extensions:
                pattern = str(video_path / f"*{ext}")
                image_files.extend(glob.glob(pattern))
                pattern = str(video_path / f"*{ext.upper()}")
                image_files.extend(glob.glob(pattern))
            
            image_files.sort()
            
            if len(image_files) == 0:
                logger.warning(f"No image files found in {video_path}")
                return []
            
            if len(image_files) <= sample_frames:
                return image_files
            else:
                step = len(image_files) // sample_frames
                return image_files[::step][:sample_frames]
                
        elif video_path.is_file():
            return self._extract_frames_from_video(str(video_path), sample_frames)
        else:
            logger.error(f"Invalid video path: {video_path}")
            return []
    
    def _extract_frames_from_video(self, video_path, sample_frames=5):
        try:
            cap = cv2.VideoCapture(video_path)
            if not cap.isOpened():
                logger.error(f"Cannot open video: {video_path}")
                return []
            
            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
            if total_frames == 0:
                cap.release()
                return []

            step = max(1, total_frames // sample_frames)
            frame_indices = [i * step for i in range(sample_frames)]
            
            os.makedirs(temp_dir, exist_ok=True)
            
            extracted_frames = []
            
            for i, frame_idx in enumerate(frame_indices):
                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
                ret, frame = cap.read()
                if ret:
                    frame_path = os.path.join(temp_dir, f"frame_{i:04d}.jpg")
                    cv2.imwrite(frame_path, frame)
                    extracted_frames.append(frame_path)
            
            cap.release()
            return extracted_frames
            
        except Exception as e:
            logger.error(f"Error extracting frames from {video_path}: {e}")
            return []
    
    def compute_quantity_accuracy(self, video_path, edit_prompt, tolerance=0.5):
        target_count, object_name = self.parse_edit_prompt(edit_prompt)
        
        if target_count is None or object_name is None:
            logger.warning(f"Cannot parse edit prompt: {edit_prompt}")
            return 0
        
        detected_count, frame_counts = self.count_objects_in_frames(video_path, object_name)
        
        error = abs(detected_count - target_count)
        is_correct = error <= tolerance
        
        score = 1 if is_correct else 0
        
        logger.debug(f"Target: {target_count} {object_name}, Detected: {detected_count:.1f}, "
                    f"Error: {error:.1f}, Correct: {is_correct}, Score: {score}")
        
        return score


def is_quantity_editing_task(video_info):
    category = video_info.get('category', '').strip().lower()
    return category == "quantity_modification"


def quantity_accuracy_single_video(evaluator, video_info, target_videos_path, use_frames=True):
    video_name = video_info['src_video_name']
    video_id = video_info['id']
    category = video_info.get('category', '')
    subcategory = video_info.get('subcategory', '')
    edit_prompt = video_info.get('edit_prompt', video_info.get('target_prompt', ''))
    
    if not is_quantity_editing_task(video_info):
        logger.debug(f"Video {video_name} is not a quantity editing task, returning -1")
        return {
            'video_id': int(video_id),
            'video_name': str(video_name),
            'video_results': -1, 
            'edit_prompt': str(edit_prompt),
            'category': str(category),
            'subcategory': str(subcategory),
            'note': 'Not a quantity editing task'
        }
    
    if not edit_prompt:
        logger.warning(f"No edit_prompt found for quantity editing video {video_name}")
        return {
            'video_id': int(video_id),
            'video_name': str(video_name),
            'video_results': -2, 
            'edit_prompt': '',
            'category': str(category),
            'subcategory': str(subcategory),
            'error': 'No edit_prompt found for quantity editing task'
        }
    
    try:
        if use_frames:
            video_name_without_ext = os.path.splitext(video_name)[0]
            target_video_path = os.path.join(target_videos_path, video_name_without_ext)
        else:
            target_video_path = os.path.join(target_videos_path, video_name)
        
        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': -3, 
                'edit_prompt': str(edit_prompt),
                'category': str(category),
                'subcategory': str(subcategory),
                'error': error_msg
            }
        
        accuracy = evaluator.compute_quantity_accuracy(target_video_path, edit_prompt)
        
        return {
            'video_id': int(video_id),
            'video_name': str(video_name),
            'video_results': int(accuracy), 
            'edit_prompt': str(edit_prompt),
            'category': str(category),
            'subcategory': str(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': 0, 
            'edit_prompt': str(edit_prompt),
            'category': str(category),
            'subcategory': str(subcategory),
            'error': error_msg
        }


def quantity_accuracy_evaluation(video_info_list, target_videos_path, config_file, checkpoint_path, 
                               device="cuda", use_frames=True, box_threshold=0.3, text_threshold=0.25):
    scores = []
    video_results = []
    valid_task_count = 0  # 重命名，表示真正有效评估的任务数
    correct_count = 0
    
    try:
        evaluator = QuantityAccuracyEvaluator(config_file, checkpoint_path, device, box_threshold, text_threshold)
    except Exception as e:
        error_msg = f"Failed to initialize GroundingDINO evaluator: {e}"
        logger.error(error_msg)
        # Return results with errors for all quantity editing tasks
        for video_info in video_info_list:
            if is_quantity_editing_task(video_info):
                video_results.append({
                    'video_id': int(video_info['id']),
                    'video_name': str(video_info['src_video_name']),
                    'video_results': 0,
                    'edit_prompt': str(video_info.get('edit_prompt', video_info.get('target_prompt', ''))),
                    'category': str(video_info.get('category', '')),
                    'subcategory': str(video_info.get('subcategory', '')),
                    'error': error_msg
                })
            else:
                video_results.append({
                    'video_id': int(video_info['id']),
                    'video_name': str(video_info['src_video_name']),
                    'video_results': -1,
                    'edit_prompt': str(video_info.get('edit_prompt', video_info.get('target_prompt', ''))),
                    'category': str(video_info.get('category', '')),
                    'subcategory': str(video_info.get('subcategory', '')),
                    'note': 'Not a quantity editing task'
                })
        return 0.0, video_results
    
    logger.info(f"Processing {len(video_info_list)} videos for quantity accuracy evaluation")
    
    for video_info in tqdm(video_info_list, desc="Evaluating quantity accuracy"):
        result = quantity_accuracy_single_video(evaluator, video_info, target_videos_path, use_frames)
        video_results.append(result)
        
        # 只计算真正有效的评估结果（video_results为0或1，且没有error）
        if result['video_results'] in [0, 1] and 'error' not in result:
            valid_task_count += 1
            scores.append(result['video_results'])
            if result['video_results'] == 1:
                correct_count += 1
            logger.debug(f"Video {result['video_name']}: quantity accuracy = {result['video_results']}")
        elif result['video_results'] == -1:
            logger.debug(f"Video {result['video_name']}: not a quantity editing task")
        else:
            # video_results 为 -2, -3 或有error的情况
            if 'error' in result:
                logger.warning(f"Video {result['video_name']}: {result['error']}")
            else:
                logger.warning(f"Video {result['video_name']}: skipped (result code: {result['video_results']})")
    
    if valid_task_count > 0:
        accuracy_rate = correct_count / valid_task_count
        logger.info(f"Valid quantity editing tasks: {valid_task_count}, Correct: {correct_count}, "
                   f"Accuracy rate: {accuracy_rate:.4f}")
    else:
        accuracy_rate = 0.0
        logger.warning("No valid quantity editing task evaluations")
    
    return float(accuracy_rate), video_results


def compute_quantity_accuracy(json_dir, device, source_videos_path=None, target_videos_path=None, 
                            config_file=None, checkpoint_path=None, use_frames=True, 
                            box_threshold=0.3, text_threshold=0.25, path_yml='path.yml', **kwargs):
    """
    Compute quantity accuracy metric using GroundingDINO
    
    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
        config_file: Path to GroundingDINO config file (if None, will load from path.yml)
        checkpoint_path: Path to GroundingDINO checkpoint (if None, will load from path.yml)
        use_frames: Whether to use frames or video files
        box_threshold: Box threshold for detection
        text_threshold: Text threshold for detection
        path_yml: Path to the YAML file containing model paths
        **kwargs: Additional arguments
    
    Returns:
        tuple: (accuracy_rate, video_results)
    """
    try:
        if not GROUNDING_DINO_AVAILABLE:
            error_msg = "GroundingDINO not available. Please install groundingdino package."
            logger.error(error_msg)
            return 0.0, []
        
        # Load config and checkpoint paths from path.yml if not provided
        if config_file is None or checkpoint_path is None:
            logger.info(f"Loading model paths from {path_yml}")
            yml_config, yml_checkpoint = load_metric_paths(path_yml, 'quantity_accuracy')
            
            if config_file is None:
                config_file = yml_config
            if checkpoint_path is None:
                checkpoint_path = yml_checkpoint
            
            if config_file is None or checkpoint_path is None:
                error_msg = "Config file and checkpoint path must be provided either as arguments or in path.yml"
                logger.error(error_msg)
                return 0.0, []
        
        video_info_list = load_video_info(json_dir, 'quantity_accuracy')
        logger.info(f"Loaded {len(video_info_list)} video entries")
        
        if target_videos_path is None:
            raise ValueError("target_videos_path is required for quantity accuracy evaluation")
        
        if not os.path.exists(target_videos_path):
            raise FileNotFoundError(f"Target videos path not found: {target_videos_path}")
        
        overall_score, video_results = quantity_accuracy_evaluation(
            video_info_list, target_videos_path, config_file, checkpoint_path,
            device, use_frames, box_threshold, text_threshold
        )
        
        logger.info(f"Quantity accuracy evaluation completed. Overall accuracy rate: {overall_score:.4f}")
        
        return overall_score, video_results
        
    except Exception as e:
        error_msg = f"Error in compute_quantity_accuracy: {str(e)}"
        logger.error(error_msg)
        return 0.0, []