benchmarks/edit/code/FiVE-Bench/evaluation/evaluate.py

import json
import argparse
import math
import os
import numpy as np
import glob
import csv
import cv2
import torch
import subprocess
from pathlib import Path
from PIL import Image
from tqdm import tqdm
from omegaconf import OmegaConf


from torchvision.io import read_video
from decord import VideoReader, cpu
import imageio

from metrics_calculator import MetricsCalculator, average_niqe_from_txt


def mask_decode(encoded_mask, image_shape=[512,512]):
    length = image_shape[0] * image_shape[1]
    mask_array = np.zeros((length,))
    
    for i in range(0, len(encoded_mask), 2):
        splice_len = min(encoded_mask[i+1], length-encoded_mask[i])
        for j in range(splice_len):
            mask_array[encoded_mask[i]+j]=1
            
    mask_array = mask_array.reshape(image_shape[0], image_shape[1])
    # to avoid annotation errors in boundary
    mask_array[0,:]=1
    mask_array[-1,:]=1
    mask_array[:,0]=1
    mask_array[:,-1]=1
            
    return mask_array



def calculate_metric(metrics_calculator, metric, src_image, tgt_image, src_mask, tgt_mask,src_prompt,tgt_prompt, 
                     src_image_path, tgt_image_path, src_save_file_niqe, tgt_save_file_niqe):
    if metric=="psnr":
        return metrics_calculator.calculate_psnr(src_image, tgt_image, None, None)
    if metric=="lpips":
        return metrics_calculator.calculate_lpips(src_image, tgt_image, None, None)
    if metric=="mse":
        return metrics_calculator.calculate_mse(src_image, tgt_image, None, None)
    if metric=="ssim":
        return metrics_calculator.calculate_ssim(src_image, tgt_image, None, None)
    if metric=="structure_distance":
        return metrics_calculator.calculate_structure_distance(src_image, tgt_image, None, None)
    if metric=="psnr_unedit_part":
        if (1-src_mask).sum()==0 or (1-tgt_mask).sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_psnr(src_image, tgt_image, 1-src_mask, 1-tgt_mask)
    if metric=="lpips_unedit_part":
        if (1-src_mask).sum()==0 or (1-tgt_mask).sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_lpips(src_image, tgt_image, 1-src_mask, 1-tgt_mask)
    if metric=="mse_unedit_part":
        if (1-src_mask).sum()==0 or (1-tgt_mask).sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_mse(src_image, tgt_image, 1-src_mask, 1-tgt_mask)
    if metric=="ssim_unedit_part":
        if (1-src_mask).sum()==0 or (1-tgt_mask).sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_ssim(src_image, tgt_image, 1-src_mask, 1-tgt_mask)
    if metric=="structure_distance_unedit_part":
        if (1-src_mask).sum()==0 or (1-tgt_mask).sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_structure_distance(src_image, tgt_image, 1-src_mask, 1-tgt_mask)
    if metric=="psnr_edit_part":
        if src_mask.sum()==0 or tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_psnr(src_image, tgt_image, src_mask, tgt_mask)
    if metric=="lpips_edit_part":
        if src_mask.sum()==0 or tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_lpips(src_image, tgt_image, src_mask, tgt_mask)
    if metric=="mse_edit_part":
        if src_mask.sum()==0 or tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_mse(src_image, tgt_image, src_mask, tgt_mask)
    if metric=="ssim_edit_part":
        if src_mask.sum()==0 or tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_ssim(src_image, tgt_image, src_mask, tgt_mask)
    if metric=="structure_distance_edit_part":
        if src_mask.sum()==0 or tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_structure_distance(src_image, tgt_image, src_mask, tgt_mask)
    if metric=="clip_similarity_source_image":
        return metrics_calculator.calculate_clip_similarity(src_image, src_prompt,None)
    if metric=="clip_similarity_target_image":
        return metrics_calculator.calculate_clip_similarity(tgt_image, tgt_prompt,None)
    if metric=="clip_similarity_target_image_edit_part":
        if tgt_mask.sum()==0:
            return "nan"
        else:
            return metrics_calculator.calculate_clip_similarity(tgt_image, tgt_prompt, tgt_mask)
    if metric == "niqe_source_image":
        return metrics_calculator.calculate_NIQE(src_save_file_niqe, img_pred_path=src_image_path, img_gt_path=None)
    if metric == "niqe_target_image":
        return metrics_calculator.calculate_NIQE(tgt_save_file_niqe, img_pred_path=None, img_gt_path=tgt_image_path)
    
def calculate_metric_video_level(metrics_calculator, metric, src_video_path, tgt_video_path, 
                                 multiple_choice_question=None, source_yes_no_question=None, target_yes_no_question=None,
                                 tgt_prompt=None, tgt_images=None, tgt_word=None, tgt_video_mask=None,
                                 ):
    if metric in {"motion_fidelity_score", "motion_fidelity_score_edit_part"}:
        return metrics_calculator.calculate_motion_fidelity_score(
            src_video_path, tgt_video_path, 
            video_masks=tgt_video_mask if metric == "motion_fidelity_score_edit_part" else None
        )
    elif metric == "five_acc":
        return metrics_calculator.calculate_five_acc(
            source_yes_no_question, target_yes_no_question, multiple_choice_question, tgt_video_path
        )
    else:
        raise ValueError(f"Metric {metric} not supported")


def list_images(directory):
    image_extensions = ('*.png', '*.jpg', '*.jpeg')

    # Create a list to store image paths
    image_files = []
    
    # Loop through each extension and find matching files
    for ext in image_extensions:
        image_files.extend(glob.glob(os.path.join(directory, ext)))
    
    return sorted(image_files)

def mp4_to_frames_ffmpeg(video_path):
    output_dir = video_path.replace(".mp4", "")
    os.makedirs(output_dir, exist_ok=True)

    # Use ffmpeg to extract frames
    output_pattern = os.path.join(output_dir, "%05d.jpg")  # Frame naming pattern
    command = [
        "ffmpeg",
        "-i", video_path,  # Input video file
        output_pattern  # Output frame pattern
    ]

    subprocess.run(command, check=True)
    return output_dir

def calculate_mean(evaluation_result):
    if evaluation_result is None:
        return "nan"
    
    # Filter out 'nan' values
    non_nan_values = [x for x in evaluation_result if x != "nan" and not math.isnan(x)]
    
    # If all values are 'nan', return 'nan'
    if not non_nan_values:
        return "nan"
    
    # Calculate the mean of non-'nan' values
    return sum(non_nan_values) / len(non_nan_values)

    
def main(args, config, all_tgt_video_folders):
    annotation_mapping_files = args.annotation_mapping_files
    metrics = args.metrics
    src_image_folder = args.src_image_folder
    tgt_methods = args.tgt_methods
    edit_category_list = args.edit_category_list
    evaluate_whole_table = args.evaluate_whole_table
    frame_stride = args.frame_stride
    if args.evaluate_source_video:
        tgt_video_folders = {
            "source_videos": (os.path.join(src_image_folder, "images"), "")
        }
        args.result_path = args.result_path.replace(".csv", "_source_videos.csv")
    else:
        tgt_video_folders = {}
        if evaluate_whole_table:
            for key in all_tgt_video_folders:
                if key[0] in tgt_methods:
                    tgt_video_folders[key] = all_tgt_video_folders[key]
        else:
            for key in tgt_methods:
                tgt_video_folders[key] = all_tgt_video_folders[key]
    
    result_path = args.result_path.replace(".csv", f"_frame_stride{frame_stride}.csv")
    result_path_name = result_path.split('/')[-1]
    result_dir = '/'.join(result_path.split('/')[:-1])
    Path(result_dir).mkdir(parents=True, exist_ok=True)

    metrics_calculator = MetricsCalculator(args.device, config=config)
    
    result_avg_files = []
    for annotation_mapping_file in tqdm(annotation_mapping_files, desc="Evaluating annotation mapping files", total=len(annotation_mapping_files)):
        print(f"evaluating {annotation_mapping_file} ...")

        annotation_mapping_file_name = annotation_mapping_file.split("/")[-1].replace(".json", "")
        result_path = os.path.join(
            result_dir, 
            "_".join([annotation_mapping_file_name, result_path_name])
        )

        with open(result_path,'w',newline="") as f:
            csv_write = csv.writer(f)
            
            csv_head = []
            for tgt_video_folder_key, _ in tgt_video_folders.items():
                for metric in metrics:
                    if metric in {"five_acc"}:
                        csv_head.append(f"{tgt_video_folder_key}|{metric}_yes_no")
                        csv_head.append(f"{tgt_video_folder_key}|{metric}_multi_choice")
                        csv_head.append(f"{tgt_video_folder_key}|{metric}_union")
                        csv_head.append(f"{tgt_video_folder_key}|{metric}_inter")
                        csv_head.append(f"{tgt_video_folder_key}|{metric}")
                    else:
                        csv_head.append(f"{tgt_video_folder_key}|{metric}")
            
            data_row = ["file_id"] + csv_head
            csv_write.writerow(data_row)

        with open(annotation_mapping_file, "r") as f:
            annotation_file = json.load(f)

        for key, item in tqdm(enumerate(annotation_file), desc="Evaluating videos", total=len(annotation_file)):
            if str(item["editing_type_id"]) not in edit_category_list:
                continue

            video_name = item["video_name"]
            save_dir = str(item["editing_type_id"]) + "_" + item["target_prompt"][:len(item["save_dir"])-2]  # item["save_dir"]
            source_prompt = item["source_prompt"].replace("[", "").replace("]", "")
            target_prompt = item["target_prompt"].replace("[", "").replace("]", "")
            # FiVE_acc
            # "multiple_choice_question": "Is the cyclist wearing a helmet? \na) Yes \nb) No",
            # "source_yes_no_question": "Is the cyclist wearing a helmet in the image?",
            # "target_yes_no_question": "Is the cyclist not wearing a helmet in the image?"
            if "multiple_choice_question" in item:
                multiple_choice_question = item["multiple_choice_question"]
                source_yes_no_question = item["source_yes_no_question"]
                target_yes_no_question = item["target_yes_no_question"]
            else:
                multiple_choice_question = None
                source_yes_no_question = None
                target_yes_no_question = None

            src_video_path = os.path.join(src_image_folder, "images", video_name)
            src_image_names = list_images(src_video_path)[::frame_stride]
            if args.evaluate_source_video:
                src_image_names = src_image_names[:40//frame_stride]

            src_images = [
                Image.open(src_image_name)
                for src_image_name in src_image_names
            ]

            mask_path = os.path.join(src_image_folder, "bmasks", video_name)
            if not os.path.exists(mask_path):
                print(f"{video_name}'s mask cannot be found!! Skip ...")
                continue

            masks = []
            for src_image_name in src_image_names:
                mask = Image.open(os.path.join(mask_path, src_image_name.split('/')[-1]))

                # Convert the mask to a numpy array and ensure it's binary (0 and 1)
                # mask = mask_decode(item["mask"])
                mask = np.array(mask)  # Convert to numpy array
                mask = (mask > 0)
                mask = mask[:,:,np.newaxis].repeat([3],axis=2)
                masks.append(mask)
        
            evaluation_result = [key]
            
            for m_i, (tgt_video_folder_key, (tgt_video_folder, terminal_folder)) in enumerate(tgt_video_folders.items()):
                src_save_file_niqe = "_".join([
                    result_path.replace(".csv", ""), "niqe_src.txt"
                ])
                tgt_save_file_niqe = "_".join([
                    result_path.replace(".csv", ""), "niqe_"+tgt_video_folder_key+"_tgt.txt"
                ])

                if not args.evaluate_source_video:
                    if tgt_video_folder_key != "6_VideoGrain":
                        tgt_video_name = os.path.join(video_name, save_dir, terminal_folder)  # terminal_folder = "image_ode" in TokenFlow
                    else:
                        prefix = annotation_mapping_file.split('/')[-1][:5]
                        assert prefix.startswith("edit")
                        tgt_video_name = os.path.join(prefix, video_name)
                    tgt_video_path = os.path.join(tgt_video_folder, tgt_video_name)
                else:
                    tgt_video_path = src_video_path
                print(f"\n\nevaluating method: {tgt_video_folder_key}")
                
                if tgt_video_path.endswith("/"):
                    tgt_video_path = tgt_video_path[:-1]
                tgt_video_path_mp4 = tgt_video_path + '.mp4'
                if os.path.exists(tgt_video_path_mp4):   
                    # NOTE: must use ffmpeg!!
                    tgt_video_path = mp4_to_frames_ffmpeg(tgt_video_path_mp4)

                tgt_image_names = list_images(tgt_video_path)
                tgt_image_names = tgt_image_names[::frame_stride]
                tgt_images = []
                for f_i, tgt_image_name in enumerate(tgt_image_names):
                    if tgt_image_name.endswith(".jpg") or tgt_image_name.endswith(".png"):
                        tgt_image = Image.open(tgt_image_name).resize(src_images[0].size)  
                        tgt_images.append(tgt_image)

                        tgt_image_name = os.path.join(
                            "/".join(tgt_image_name.split('/')[:-1])+"_resize", 
                            os.path.basename(tgt_image_name)
                        )
                        tgt_image_names[f_i] = tgt_image_name
                        Path("/".join(tgt_image_name.split('/')[:-1])).mkdir(parents=True, exist_ok=True)
                        tgt_image.save(tgt_image_name)
                
                for m_j, metric in enumerate(metrics):
                    if metric in {"niqe_source_image"} and m_i > 0:
                        continue

                    print(f"\nevaluating metric: {metric}")
                    if len(tgt_images) == 0:
                        print(f"No images are founded {tgt_video_path}! Skip ...")
                        if metric in {"five_acc"}:
                            evaluation_result += ["nan"] * 5
                        else:
                            evaluation_result.append("nan")
                        continue
                    
                    assert len(os.listdir(src_video_path)) > 0 and \
                        len(tgt_images) > 0, f"No images are founded!"

                    try:
                        if metric in {"motion_fidelity_score", "motion_fidelity_score_edit_part", "five_acc"}:
                            if args.evaluate_source_video:
                                eval_result_ = (
                                    calculate_metric_video_level(
                                        metrics_calculator, metric,
                                        src_video_path, src_video_path,
                                        multiple_choice_question=multiple_choice_question,
                                        source_yes_no_question=source_yes_no_question,
                                        target_yes_no_question=target_yes_no_question,
                                        tgt_video_mask=masks
                                    )
                                )
                            else:
                                eval_result_ = (
                                    calculate_metric_video_level(
                                        metrics_calculator, metric,
                                        src_video_path, tgt_video_path,
                                        multiple_choice_question=multiple_choice_question,
                                        source_yes_no_question=source_yes_no_question,
                                        target_yes_no_question=target_yes_no_question,
                                        tgt_video_mask=masks
                                    )
                                )
                            # Five_acc ouputs YN-acc and MC-acc 
                            if metric in {"five_acc"}:
                                if "nan" in eval_result_:
                                    evaluation_result += ["nan"] * 5
                                else:
                                    eval_result_ =  list(eval_result_)
                                    evaluation_result_five = []
                                    for eval_result_s in list(eval_result_):
                                        evaluation_result_five.append(eval_result_s)
                                    evaluation_result_five.append(int(sum(eval_result_) > 0))
                                    evaluation_result_five.append(int(sum(eval_result_) >= len(eval_result_)))
                                    evaluation_result_five.append(calculate_mean(evaluation_result_five))
                                    evaluation_result += evaluation_result_five
                            else:
                                evaluation_result.append(eval_result_)

                        else:
                            
                            if metric in {"niqe_source_image", "niqe_target_image"}:
                                if os.path.exists(src_save_file_niqe if metric == "niqe_source_image" else tgt_save_file_niqe):
                                    os.remove(src_save_file_niqe if metric == "niqe_source_image" else tgt_save_file_niqe)

                            evaluation_result_each_frame = []
                            for src_image, tgt_image, mask, src_image_path, tgt_image_path, in zip(src_images[:len(tgt_images)], tgt_images, masks, src_image_names[:len(tgt_images)], tgt_image_names):
                                assert src_image.size[0] == tgt_image.size[0] and src_image.size[1] == tgt_image.size[1], \
                                    f"{tgt_video_folder_key}: {src_image.size} != {tgt_image.size})"
                                
                                if args.evaluate_source_video:
                                    evaluation_result_each_frame.append(
                                        calculate_metric(
                                            metrics_calculator, metric, 
                                            src_image, src_image, 
                                            mask, mask, 
                                            source_prompt, target_prompt,
                                            src_image_path, src_image_path, 
                                            src_save_file_niqe, src_save_file_niqe,
                                        )
                                    )
                                else:
                                    evaluation_result_each_frame.append(
                                        calculate_metric(
                                            metrics_calculator, metric, 
                                            src_image, tgt_image, 
                                            mask, mask, 
                                            source_prompt, target_prompt,
                                            src_image_path, tgt_image_path, 
                                            src_save_file_niqe, tgt_save_file_niqe,
                                        )
                                    )
                            
                            if metric in {"niqe_source_image", "niqe_target_image"}:
                                evaluation_result.append(
                                    average_niqe_from_txt(src_save_file_niqe if metric == "niqe_source_image" else tgt_save_file_niqe)
                                )
                            else:
                                evaluation_result.append(
                                    calculate_mean(evaluation_result_each_frame)
                                )

                    except Exception as e:
                        print(f"Error: {metric}: {e}")
                        continue
                      
            with open(result_path, 'a+', newline="") as f:
                csv_write = csv.writer(f)
                csv_write.writerow(evaluation_result)
 
        # calculate the average of each metric (each column)
        with open(result_path, 'r') as f:
            reader = list(csv.reader(f))
            header, rows = reader[0], reader[1:]

        avg_row = []
        # Process each column by index to handle rows with different lengths
        for col_idx, name in enumerate(header):
            print("processing", name)
            # Extract column values, handling missing values
            col_values = []
            for row in rows:
                if col_idx < len(row):
                    col_values.append(row[col_idx])
                else:
                    col_values.append("")  # Use empty string for missing values
            
            try:
                # Filter out empty strings and convert to float
                values = [float(x) for x in col_values if x != "" and x != "nan"]
                if values:  # Only calculate average if there are valid values
                    avg = sum(values) / len(values)
                    if 'structure_distance' in name:
                        avg *= 1000
                    elif 'lpips_' in name:
                        avg *= 1000
                    elif 'mse_' in name:
                        avg *= 10000
                    elif 'ssim_' in name:
                        avg *= 100
                    elif 'motion_fidelity_score' in name:
                        avg *= 100
                    elif name.startswith('five_acc'):
                        avg *= 100
                    avg_row.append(f"{avg:.4f}")
                else:
                    avg_row.append("N/A")
            except ValueError:
                avg_row.append("N/A")

        result_avg_files.append(result_path.replace('.csv', '_avg.csv'))
        with open(result_avg_files[-1], 'w', newline='') as f_out:
            writer = csv.writer(f_out)
            writer.writerow(header)
            writer.writerow(avg_row)
    
    # average the results in result_avg_files
    if result_avg_files:
        all_avg_rows = []
        
        # Read all average files
        for result_avg_file in result_avg_files:
            with open(result_avg_file, 'r') as f:
                reader = list(csv.reader(f))
                header, rows = reader[0], reader[1:]
                if rows:  # Make sure there's data
                    all_avg_rows.append(rows[0])  # Get the average row
        
        # Calculate final averages across all files
        final_avg_row = []
        for col_idx, name in enumerate(header):
            print("final averaging", name)
            
            # Extract values from all average files for this column
            col_values = []
            for avg_row in all_avg_rows:
                if col_idx < len(avg_row) and avg_row[col_idx] != "N/A":
                    try:
                        col_values.append(float(avg_row[col_idx]))
                    except ValueError:
                        pass  # Skip non-numeric values
            
            # Calculate final average
            if col_values:
                final_avg = sum(col_values) / len(col_values)
                final_avg_row.append(f"{final_avg:.4f}")
            else:
                final_avg_row.append("N/A")
        
        # Write final averaged results
        with open(f"{os.path.dirname(result_avg_files[0])}/final_averaged_results.csv", 'w', newline='') as f_out:
            writer = csv.writer(f_out)
            writer.writerow(header)
            writer.writerow(final_avg_row)


if __name__=="__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--frame_stride", type=int, default=8)
    parser.add_argument('--annotation_mapping_files', nargs = '+', type=str, default=[
                                                        "data/edit_prompt/edit1_FiVE.json",
                                                        "data/edit_prompt/edit2_FiVE.json",
                                                        "data/edit_prompt/edit3_FiVE.json",
                                                        "data/edit_prompt/edit4_FiVE.json",
                                                        "data/edit_prompt/edit5_FiVE.json",
                                                        "data/edit_prompt/edit6_FiVE.json",
                                                        ])
    parser.add_argument('--metrics', nargs = '+', type=str, default=[
                                                         "structure_distance",
                                                         "psnr_unedit_part",
                                                         "lpips_unedit_part",
                                                         "mse_unedit_part",
                                                         "ssim_unedit_part",
                                                         "clip_similarity_source_image",
                                                         "clip_similarity_target_image",
                                                         "clip_similarity_target_image_edit_part",
                                                        #  "niqe_source_image",
                                                         "niqe_target_image",
                                                         "motion_fidelity_score",
                                                         "motion_fidelity_score_edit_part",
                                                         "five_acc",    
                                                        ])
    parser.add_argument('--src_image_folder', type=str, default="data/")
    parser.add_argument('--tgt_methods', nargs = '+', type=str, default=[
                                                                    # "1_TokenFlow",
                                                                    # "2_DMT",
                                                                    # "4_VidToMe",
                                                                    # "5_AnyV2V",
                                                                    # "6_VideoGrain",
                                                                    # "7_Pyramid_Edit",
                                                                    "8_Wan_Edit",
                                                                  ])
    parser.add_argument('--result_path', type=str, default="outputs/evaluation_result.csv")
    parser.add_argument('--device', type=str, default="cuda")
    parser.add_argument('--edit_category_list',  nargs = '+', type=str, default=[
                                                                                "1",
                                                                                "2",
                                                                                "3",
                                                                                "4",
                                                                                "5",
                                                                                "6",
                                                                                ]) # the editing category that needed to run
    parser.add_argument('--evaluate_whole_table', action= "store_true") # rerun existing images
    parser.add_argument('--evaluate_source_video', action= "store_true")
    parser.add_argument('--config_path', type=str, default="config.yaml")
    args = parser.parse_args()

    config = OmegaConf.load(args.config_path)
    args_dict = vars(args)
    for key, value in args_dict.items():
        if key in config and value is not None:
            config[key] = value
    
    # NOTE: Modify the target video folders here!!!!! 
    all_tgt_video_folders = {
        # "1_TokenFlow": (f"{config.root_tgt_video_folder}/TokenFlow/", "img_ode"),
        # "2_DMT": (f"{config.root_tgt_video_folder}/diffusion-motion-transfer/", "result_frames"),
        # "4_VidToMe": (f"{config.root_tgt_video_folder}/VidToMe/", "frames"),
        # "5_AnyV2V": (f"{config.root_tgt_video_folder}/AnyV2V/Results/Prompt-Based-Editing_frames32/i2vgen-xl", "ddim_init_latents_t_idx_0_nsteps_50_cfg_9.0_pnpf0.2_pnps0.2_pnpt0.5"),
        # "6_VideoGrain": (f"{config.root_tgt_video_folder}/video_grain/", ""),
        "7_Pyramid_Edit": (f"{config.root_tgt_video_folder}/Pyramid-edit/", "result_all_frames"),
        "8_Wan_Edit": (f"{config.root_tgt_video_folder}/Wan-Edit/", ""),
    }

    main(args, config, all_tgt_video_folders)