Add files using upload-large-folder tool

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/egoexobench.py

@@ -0,0 +1,301 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ...smp import *
+from ..video_base import VideoBaseDataset
+from ..utils import build_judge, DEBUG_MESSAGE
+import torchvision.transforms as T
+from torchvision import transforms
+import pandas as pd
+import os
+import re
+from .utils import *
+import torch
+import shutil
+import glob
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class EgoExoBench_MCQ(VideoBaseDataset):
+    MD5 = '9c0aa8da235d766d02dd7e9a19182719'
+    TYPE = 'Video-MCQ'
+
+    def __init__(self, dataset='EgoExoBench_MCQ', nframe=64, skip_EgoExo4D=False):
+        super().__init__(dataset=dataset, nframe=nframe)
+        self.frame_fps = 2
+        self.skip_EgoExo4D = skip_EgoExo4D
+
+    @classmethod
+    def supported_datasets(cls):
+        return ['EgoExoBench_MCQ']
+
+    def prepare_dataset(self, dataset_name='EgoExoBench_MCQ', repo_id='Heleun/EgoExoBench_MCQ', video_repo_id='onlyfaces/EgoExoBench'):  # noqa: E501
+        def check_integrity(pth):
+            data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+            if not osp.exists(data_file):
+                return False
+
+            if md5(data_file) != self.MD5:
+                return False
+
+            return True
+        cache_path = get_cache_path(repo_id)
+        self.video_root = os.path.join(LMUDataRoot(), 'videos', 'EgoExoBench')
+        os.makedirs(self.video_root, exist_ok=True)
+        if not osp.exists(osp.join(self.video_root, 'processed_videos')) or not osp.exists(osp.join(self.video_root, 'processed_frames')):  # noqa: E501
+            snapshot_download(
+                repo_id=video_repo_id,
+                repo_type='dataset',
+                allow_patterns=['*.tar.gz.part*'],
+                local_dir=self.video_root
+            )
+
+            def combine_and_extract(root_dir, prefix, remove_parts=True):
+                parts_pattern = osp.join(root_dir, f'{prefix}.tar.gz.part*')
+                combined_archive = osp.join(root_dir, f'{prefix}.tar.gz')
+                if not osp.exists(combined_archive):
+                    parts = sorted(glob.glob(parts_pattern))
+                    with open(combined_archive, 'wb') as outfile:
+                        for part in parts:
+                            with open(part, 'rb') as infile:
+                                shutil.copyfileobj(infile, outfile)
+                shutil.unpack_archive(combined_archive, root_dir)
+                if remove_parts:
+                    for part in parts:
+                        os.remove(part)
+                    os.remove(combined_archive)
+
+            combine_and_extract(self.video_root, 'processed_videos')
+            combine_and_extract(self.video_root, 'processed_frames')
+
+        if cache_path is not None and check_integrity(cache_path):
+            dataset_path = cache_path
+        else:
+            dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+
+        data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+        # transform
+        self.transform = T.Compose([
+            Stack(),
+            ToTorchFormatTensor()
+        ])
+
+        return dict(root=dataset_path, data_file=data_file)
+
+    def get_index(self, bound, fps, max_frame, first_idx=0, num_segments=16):
+        start, end = bound if bound else (-100000, 100000)
+        start_idx = max(first_idx, round(start * fps))
+        end_idx = min(round(end * fps), max_frame)
+        seg_size = (end_idx - start_idx) / num_segments
+        mid_seg_size = seg_size / 2
+        indices = np.arange(num_segments)
+        frame_indices = start_idx + mid_seg_size + np.round(seg_size * indices)
+        return frame_indices.astype(int)
+
+    def load_into_video_and_process(self, media, mcq_idx):
+        try:
+            from moviepy.editor import VideoFileClip, ImageSequenceClip
+        except:
+            raise ImportError(
+                'MoviePy is not installed, please install it by running "pip install moviepy==1.0.3"'
+            )
+        video_root = self.video_root
+        if media['type'] in ['image']:
+            original_image_path = osp.join(video_root, media['image_paths'][0])
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.jpg')
+            if not os.path.exists(processed_video_path):
+                shutil.copy(original_image_path, processed_video_path)
+            return dict(type='image', value=processed_video_path)
+        elif media['type'] in ['frames']:
+            input_images = [osp.join(video_root, im) for im in media['image_paths']]
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.mp4')
+            media['nframes'] = len(input_images) // 2 * 2
+            if not os.path.exists(processed_video_path):
+                # using MoviePy to transform images into mp4
+                image_files = sorted(input_images)
+                image_clip = ImageSequenceClip(image_files, fps=self.frame_fps)
+                image_clip.write_videofile(processed_video_path, codec='libx264')
+                image_clip.close()
+        elif media['type'] in ['video']:
+            original_video_path = osp.join(video_root, media['video_path'])
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.mp4')
+            if 'video_start' in media and 'video_end' in media and media['video_start'] is not None and media['video_end'] is not None:  # noqa: E501
+                video_start, video_end = media['video_start'], media['video_end']
+                if not os.path.exists(processed_video_path):
+                    video_clip = VideoFileClip(original_video_path)
+                    clip = video_clip.subclip(video_start, min(video_end, video_clip.duration))
+                    clip.write_videofile(processed_video_path)
+                    clip.close()
+            else:
+                if not os.path.exists(processed_video_path):
+                    shutil.copy(original_video_path, processed_video_path)
+        else:
+            raise ValueError(f"Unsupported media type: {media['type']}")
+
+        return dict(type='video', value=processed_video_path, nframes=media.get('nframes', 8))
+
+    def save_video_into_images(self, media, mcq_idx):
+        bound = None
+        video_root = self.video_root
+
+        if media['type'] in ['frames', 'image']:
+            media_paths = [osp.join(video_root, im) for im in media['image_paths']]
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+            os.makedirs(save_dir, exist_ok=True)
+            input_images = []
+            for media_path in media_paths:
+                img_path = media_path.split('/')[-1]
+                save_image_path = osp.join(save_dir, img_path)
+                shutil.copy(media_path, save_image_path)
+                input_images.append(save_image_path)
+            return input_images
+
+        if 'video_start' in media and 'video_end' in media and media['video_start'] is not None and media['video_end'] is not None:  # noqa: E501
+            bound = (
+                media['video_start'], media['video_end']
+            )
+        video_path = os.path.join(video_root, media['video_path'])
+
+        def read_video(video_path, bound=None, num_segments=16):
+            from decord import VideoReader, cpu
+            vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+            max_frame = len(vr) - 1
+            fps = float(vr.get_avg_fps())
+
+            images_group = list()
+            frame_indices = self.get_index(bound, fps, max_frame, first_idx=0, num_segments=num_segments)
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+
+            if osp.exists(save_dir) and len(os.listdir(save_dir)) > 0:
+                return None, frame_indices
+
+            for frame_index in frame_indices:
+                img = Image.fromarray(vr[frame_index].asnumpy())
+                images_group.append(img)
+            torch_imgs = self.transform(images_group)
+            return torch_imgs, frame_indices
+
+        def save_video_frames(imgs, video_root, frame_indices, mcq_idx):
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+            os.makedirs(save_dir, exist_ok=True)
+            frame_paths = [osp.join(save_dir, f'{fidx:07d}.jpg') for fidx in frame_indices]
+
+            flag = np.all([osp.exists(pth) for pth in frame_paths])
+
+            if not flag:
+                block_size = imgs.size(0) // len(frame_indices)
+                split_tensors = torch.split(imgs, block_size)
+                to_pil = transforms.ToPILImage()
+                images = [to_pil(arr) for arr in split_tensors]
+                for im, pth in zip(images, frame_paths):
+                    if not osp.exists(pth):
+                        im.save(pth)
+
+            return frame_paths
+
+        torch_imgs, frame_indices = read_video(video_path, bound, media['nframes'])
+        img_frame_paths = save_video_frames(torch_imgs, video_root, frame_indices, mcq_idx)
+        return img_frame_paths
+
+    def process_text_and_media(self, text, media_list, video_llm, mcq_idx):
+
+        message = []
+        chunks = re.split(r'(<image>|<video>)', text)
+        media_index = 0
+        media_list = eval(media_list)
+
+        placeholder_count = sum(1 for chunk in chunks if chunk in ['<image>', '<video>'])
+        assert placeholder_count == len(media_list), \
+            f"Placeholder count {placeholder_count} does not match media list length {len(media_list)}."
+
+        for chunk in chunks:
+            if chunk in ['<image>', '<video>']:
+                if video_llm:
+                    media_content = self.load_into_video_and_process(media_list[media_index], f'question{mcq_idx}_video{media_index}')  # noqa: E501
+                    message.append(media_content)
+                else:
+                    # Save the video as individual image frames for processing
+                    img_frame_paths = self.save_video_into_images(media_list[media_index], f'question{mcq_idx}_video{media_index}')  # noqa: E501
+                    for im in img_frame_paths:
+                        message.append(dict(type='image', value=im))
+
+                media_index += 1
+            elif chunk.strip():
+                message.append(dict(type='text', value=chunk.strip()))
+
+        return message
+
+    def build_prompt(self, line, video_llm):
+        if isinstance(line, int):
+            mcq_idx = line
+            assert line < len(self)
+            line = self.data.iloc[line]
+            mcq_idx = int(line['index'])
+        if self.skip_EgoExo4D and 'EgoExo4D' in line['medias']:
+            return None
+        text = line['question'] + '\nOptions:\n' + line['options'] + '\n' + line['response_format']
+        message = self.process_text_and_media(text, line['medias'], video_llm, mcq_idx)
+        return message
+
+    # It returns a dictionary
+    @classmethod
+    def evaluate(self, eval_file, **judge_kwargs):
+        from .utils import get_dimension_rating, extract_characters_regex, extract_option
+
+        assert get_file_extension(eval_file) in ['xlsx', 'json', 'tsv'], \
+            'data file should be an supported format (xlsx/json/tsv) file'
+
+        tmp_file = get_intermediate_file_path(eval_file, '_tmp', 'pkl')
+        tgt_file = get_intermediate_file_path(eval_file, '_rating', 'json')
+        score_file = get_intermediate_file_path(eval_file, '_score', 'csv')
+
+        if not osp.exists(score_file):
+            model = judge_kwargs.get('model', 'exact_matching')
+            assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+            if model == 'exact_matching':
+                model = None
+            elif gpt_key_set():
+                model = build_judge(**judge_kwargs)
+                if not model.working():
+                    warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+                    warnings.warn(DEBUG_MESSAGE)
+                    model = None
+            else:
+                warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+                model = None
+            res = {} if not osp.exists(tmp_file) else load(tmp_file)
+            res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+            data = load(eval_file)
+            data_un = data[~pd.isna(data['prediction'])]
+
+            for idx in data['index']:
+                ans = data.loc[data['index'] == idx, 'answer'].values[0]
+                pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+
+                if extract_characters_regex(pred) == '':
+                    extract_pred = extract_option(
+                        model,
+                        data.loc[data['index'] == idx].to_dict(orient='records')[0],
+                        'EgoExoBench_MCQ',
+                    )
+                    data.loc[idx, 'score'] = int(extract_pred == ans)
+                else:
+                    data.loc[idx, 'score'] = int(extract_characters_regex(pred) == ans)
+
+            rejected = [x for x in data['score'] if x == -1]
+
+            print(
+                f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+                f'failed to obtain the score for another {len(rejected)} questions. '
+                f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+            )
+
+            dump(data, score_file)
+
+        rating = get_dimension_rating(score_file)
+        dump(rating, tgt_file)
+        return rating

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/page_ocr_metric.py

@@ -0,0 +1,51 @@
+import json
+import argparse
+import nltk
+from nltk.metrics import precision, recall, f_measure
+import numpy as np
+import jieba
+import re
+from nltk.translate import meteor_score
+
+
+def contain_chinese_string(text):
+    chinese_pattern = re.compile(r'[\u4e00-\u9fa5]')
+    return bool(chinese_pattern.search(text))
+
+
+def cal_per_metrics(pred, gt):
+    metrics = {}
+
+    if contain_chinese_string(gt) or contain_chinese_string(pred):
+        reference = jieba.lcut(gt)
+        hypothesis = jieba.lcut(pred)
+    else:
+        reference = gt.split()
+        hypothesis = pred.split()
+
+    metrics["bleu"] = nltk.translate.bleu([reference], hypothesis)
+    metrics["meteor"] = meteor_score.meteor_score([reference], hypothesis)
+
+    reference = set(reference)
+    hypothesis = set(hypothesis)
+    metrics["f_measure"] = f_measure(reference, hypothesis)
+
+    metrics["precision"] = precision(reference, hypothesis)
+    metrics["recall"] = recall(reference, hypothesis)
+    metrics["edit_dist"] = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))
+    return metrics
+
+
+if __name__ == "__main__":
+
+    # Examples for region text recognition and read all text tasks
+    predict_text = "metrics['edit_dist'] = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+    true_text = "metrics = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+
+    scores = cal_per_metrics(predict_text, true_text)
+
+    predict_text = "metrics['edit_dist'] len(gt))"
+    true_text = "metrics = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+
+    scores = cal_per_metrics(predict_text, true_text)
+    print(scores)

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/parallel.py

@@ -0,0 +1,51 @@
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+
+def parallel_process(array, function, n_jobs=16, use_kwargs=False, front_num=0):
+    """
+        A parallel version of the map function with a progress bar.
+
+        Args:
+            array (array-like): An array to iterate over.
+            function (function): A python function to apply to the elements of array
+            n_jobs (int, default=16): The number of cores to use
+            use_kwargs (boolean, default=False): Whether to consider the elements of array as dictionaries of
+                keyword arguments to function
+            front_num (int, default=3): The number of iterations to run serially before kicking off the parallel job.
+                Useful for catching bugs
+        Returns:
+            [function(array[0]), function(array[1]), ...]
+    """
+    # We run the first few iterations serially to catch bugs
+    if front_num > 0:
+        front = [function(**a) if use_kwargs else function(a) for a in array[:front_num]]
+    else:
+        front = []
+    # If we set n_jobs to 1, just run a list comprehension. This is useful for benchmarking and debugging.
+    if n_jobs == 1:
+        return front + [function(**a) if use_kwargs else function(a) for a in tqdm(array[front_num:])]
+    # Assemble the workers
+    with ProcessPoolExecutor(max_workers=n_jobs) as pool:
+        # Pass the elements of array into function
+        if use_kwargs:
+            futures = [pool.submit(function, **a) for a in array[front_num:]]
+        else:
+            futures = [pool.submit(function, a) for a in array[front_num:]]
+        kwargs = {
+            'total': len(futures),
+            'unit': 'it',
+            'unit_scale': True,
+            'leave': True
+        }
+        # Print out the progress as tasks complete
+        for f in tqdm(as_completed(futures), **kwargs):
+            pass
+    out = []
+    # Get the results from the futures.
+    for i, future in tqdm(enumerate(futures)):
+        try:
+            out.append(future.result())
+        except Exception as e:
+            out.append(e)
+    return front + out

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/requirements.txt

@@ -0,0 +1,13 @@
+apted
+distance
+distance
+editdistance
+ipdb
+jieba
+Levenshtein
+lxml
+nltk
+numpy
+Polygon3
+tqdm
+zss

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/script.py

@@ -0,0 +1,451 @@
+# flake8: noqa
+#!/usr/bin/env python
+# encoding=utf8
+#File: E2E_iou_1_1.py
+#Version: 1.1
+#Version info: changes for Python 3
+#Date: 2019-12-29
+#Description: Evaluation script that computes End to End Recognition. For Text Localization it's used Intersection over Union criteria.
+#Average Precision is also calcuted when 'CONFIDENCES' parameter is True
+#There are 2 modes to determine if a detection is correct or not:
+#with Word Spotting: The detected word must coincide (ingnoring case) to a filtered Ground Truth containing only dictionary words (see include_in_dictionary and include_in_dictionary_transcription functions)
+#without Word Spotting: words must be equal excluding a set of special characters
+
+from collections import namedtuple
+import vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.rrc_evaluation_funcs_1_1 as rrc_evaluation_funcs
+import importlib
+
+def evaluation_imports():
+    """
+    evaluation_imports: Dictionary ( key = module name , value = alias  )  with python modules used in the evaluation.
+    """
+    return {
+            'Polygon':'plg',
+            'numpy':'np'
+            }
+
+def default_evaluation_params():
+    """
+    default_evaluation_params: Default parameters to use for the validation and evaluation.
+    """
+    return {
+            'IOU_CONSTRAINT' :0.5,
+            'AREA_PRECISION_CONSTRAINT' :0.5,
+            'WORD_SPOTTING' :False,
+            'MIN_LENGTH_CARE_WORD' :3,
+            'GT_SAMPLE_NAME_2_ID':'gt_img_([0-9]+).txt',
+            'DET_SAMPLE_NAME_2_ID':'res_img_([0-9]+).txt',
+            'LTRB':False, #LTRB:2points(left,top,right,bottom) or 4 points(x1,y1,x2,y2,x3,y3,x4,y4)
+            'CRLF':False, # Lines are delimited by Windows CRLF format
+            'CONFIDENCES':False, #Detections must include confidence value. AP will be calculated,
+            'SPECIAL_CHARACTERS':'!?.:,*"()·[]/\'',
+            'ONLY_REMOVE_FIRST_LAST_CHARACTER' : True
+        }
+
+def validate_data(gtFilePath, submFilePath, evaluationParams):
+    """
+    Method validate_data: validates that all files in the results folder are correct (have the correct name contents).
+                            Validates also that there are no missing files in the folder.
+                            If some error detected, the method raises the error
+    """
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath, evaluationParams['GT_SAMPLE_NAME_2_ID'])
+
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath, evaluationParams['DET_SAMPLE_NAME_2_ID'], True)
+
+    #Validate format of GroundTruth
+    for k in gt:
+        rrc_evaluation_funcs.validate_lines_in_file(k,gt[k],evaluationParams['CRLF'],evaluationParams['LTRB'],True)
+
+    #Validate format of results
+    for k in subm:
+        if (k in gt) == False :
+            raise Exception("The sample %s not present in GT" %k)
+
+        rrc_evaluation_funcs.validate_lines_in_file(k,subm[k],evaluationParams['CRLF'],evaluationParams['LTRB'],True,evaluationParams['CONFIDENCES'])
+
+
+def evaluate_method(gtFilePath, submFilePath, evaluationParams):
+    """
+    Method evaluate_method: evaluate method and returns the results
+        Results. Dictionary with the following values:
+        - method (required)  Global method metrics. Ex: { 'Precision':0.8,'Recall':0.9 }
+        - samples (optional) Per sample metrics. Ex: {'sample1' : { 'Precision':0.8,'Recall':0.9 } , 'sample2' : { 'Precision':0.8,'Recall':0.9 }
+    """
+    for module,alias in evaluation_imports().items():
+        globals()[alias] = importlib.import_module(module)
+
+    def polygon_from_points(points,correctOffset=False):
+        """
+        Returns a Polygon object to use with the Polygon2 class from a list of 8 points: x1,y1,x2,y2,x3,y3,x4,y4
+        """
+
+        if correctOffset: #this will substract 1 from the coordinates that correspond to the xmax and ymax
+            points[2] -= 1
+            points[4] -= 1
+            points[5] -= 1
+            points[7] -= 1
+
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(points[0])
+        resBoxes[0,4]=int(points[1])
+        resBoxes[0,1]=int(points[2])
+        resBoxes[0,5]=int(points[3])
+        resBoxes[0,2]=int(points[4])
+        resBoxes[0,6]=int(points[5])
+        resBoxes[0,3]=int(points[6])
+        resBoxes[0,7]=int(points[7])
+        pointMat = resBoxes[0].reshape([2,4]).T
+        return plg.Polygon( pointMat)
+
+    def rectangle_to_polygon(rect):
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(rect.xmin)
+        resBoxes[0,4]=int(rect.ymax)
+        resBoxes[0,1]=int(rect.xmin)
+        resBoxes[0,5]=int(rect.ymin)
+        resBoxes[0,2]=int(rect.xmax)
+        resBoxes[0,6]=int(rect.ymin)
+        resBoxes[0,3]=int(rect.xmax)
+        resBoxes[0,7]=int(rect.ymax)
+
+        pointMat = resBoxes[0].reshape([2,4]).T
+
+        return plg.Polygon( pointMat)
+
+    def rectangle_to_points(rect):
+        points = [int(rect.xmin), int(rect.ymax), int(rect.xmax), int(rect.ymax), int(rect.xmax), int(rect.ymin), int(rect.xmin), int(rect.ymin)]
+        return points
+
+    def get_union(pD,pG):
+        areaA = pD.area();
+        areaB = pG.area();
+        return areaA + areaB - get_intersection(pD, pG);
+
+    def get_intersection_over_union(pD,pG):
+        try:
+            return get_intersection(pD, pG) / get_union(pD, pG);
+        except:
+            return 0
+
+    def get_intersection(pD,pG):
+        pInt = pD & pG
+        if len(pInt) == 0:
+            return 0
+        return pInt.area()
+
+    def compute_ap(confList, matchList,numGtCare):
+        correct = 0
+        AP = 0
+        if len(confList)>0:
+            confList = np.array(confList)
+            matchList = np.array(matchList)
+            sorted_ind = np.argsort(-confList)
+            confList = confList[sorted_ind]
+            matchList = matchList[sorted_ind]
+            for n in range(len(confList)):
+                match = matchList[n]
+                if match:
+                    correct += 1
+                    AP += float(correct)/(n + 1)
+
+            if numGtCare>0:
+                AP /= numGtCare
+
+        return AP
+
+    def transcription_match(transGt,transDet,specialCharacters='!?.:,*"()·[]/\'',onlyRemoveFirstLastCharacterGT=True):
+
+        if onlyRemoveFirstLastCharacterGT:
+            #special characters in GT are allowed only at initial or final position
+            if (transGt==transDet):
+                return True
+
+            if specialCharacters.find(transGt[0])>-1:
+                if transGt[1:]==transDet:
+                    return True
+
+            if specialCharacters.find(transGt[-1])>-1:
+                if transGt[0:len(transGt)-1]==transDet:
+                    return True
+
+            if specialCharacters.find(transGt[0])>-1 and specialCharacters.find(transGt[-1])>-1:
+                if transGt[1:len(transGt)-1]==transDet:
+                    return True
+            return False
+        else:
+            #Special characters are removed from the begining and the end of both Detection and GroundTruth
+            while len(transGt)>0 and specialCharacters.find(transGt[0])>-1:
+                transGt = transGt[1:]
+
+            while len(transDet)>0 and specialCharacters.find(transDet[0])>-1:
+                transDet = transDet[1:]
+
+            while len(transGt)>0 and specialCharacters.find(transGt[-1])>-1 :
+                transGt = transGt[0:len(transGt)-1]
+
+            while len(transDet)>0 and specialCharacters.find(transDet[-1])>-1:
+                transDet = transDet[0:len(transDet)-1]
+
+            return transGt == transDet
+
+
+    def include_in_dictionary(transcription):
+        """
+        Function used in Word Spotting that finds if the Ground Truth transcription meets the rules to enter into the dictionary. If not, the transcription will be cared as don't care
+        """
+        #special case 's at final
+        if transcription[len(transcription)-2:]=="'s" or transcription[len(transcription)-2:]=="'S":
+            transcription = transcription[0:len(transcription)-2]
+
+        #hypens at init or final of the word
+        transcription = transcription.strip('-');
+
+        specialCharacters = "'!?.:,*\"()·[]/";
+        for character in specialCharacters:
+            transcription = transcription.replace(character,' ')
+
+        transcription = transcription.strip()
+
+        if len(transcription) != len(transcription.replace(" ","")) :
+            return False;
+
+        if len(transcription) < evaluationParams['MIN_LENGTH_CARE_WORD']:
+            return False;
+
+        notAllowed = "×÷·";
+
+        range1 = [ ord(u'a'), ord(u'z') ]
+        range2 = [ ord(u'A'), ord(u'Z') ]
+        range3 = [ ord(u'À'), ord(u'ƿ') ]
+        range4 = [ ord(u'DŽ'), ord(u'ɿ') ]
+        range5 = [ ord(u'Ά'), ord(u'Ͽ') ]
+        range6 = [ ord(u'-'), ord(u'-') ]
+
+        for char in transcription :
+            charCode = ord(char)
+            if(notAllowed.find(char) != -1):
+                return False
+
+            valid = ( charCode>=range1[0] and charCode<=range1[1] ) or ( charCode>=range2[0] and charCode<=range2[1] ) or ( charCode>=range3[0] and charCode<=range3[1] ) or ( charCode>=range4[0] and charCode<=range4[1] ) or ( charCode>=range5[0] and charCode<=range5[1] ) or ( charCode>=range6[0] and charCode<=range6[1] )
+            if valid == False:
+                return False
+
+        return True
+
+    def include_in_dictionary_transcription(transcription):
+        """
+        Function applied to the Ground Truth transcriptions used in Word Spotting. It removes special characters or terminations
+        """
+        #special case 's at final
+        if transcription[len(transcription)-2:]=="'s" or transcription[len(transcription)-2:]=="'S":
+            transcription = transcription[0:len(transcription)-2]
+
+        #hypens at init or final of the word
+        transcription = transcription.strip('-');
+
+        specialCharacters = "'!?.:,*\"()·[]/";
+        for character in specialCharacters:
+            transcription = transcription.replace(character,' ')
+
+        transcription = transcription.strip()
+
+        return transcription
+
+    perSampleMetrics = {}
+
+    matchedSum = 0
+
+    Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
+
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath,evaluationParams['GT_SAMPLE_NAME_2_ID'])
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath,evaluationParams['DET_SAMPLE_NAME_2_ID'],True)
+
+    numGlobalCareGt = 0;
+    numGlobalCareDet = 0;
+
+    arrGlobalConfidences = [];
+    arrGlobalMatches = [];
+
+    for resFile in gt:
+
+        gtFile = rrc_evaluation_funcs.decode_utf8(gt[resFile])
+        if (gtFile is None) :
+            raise Exception("The file %s is not UTF-8" %resFile)
+
+        recall = 0
+        precision = 0
+        hmean = 0
+        detCorrect = 0
+        iouMat = np.empty([1,1])
+        gtPols = []
+        detPols = []
+        gtTrans = []
+        detTrans = []
+        gtPolPoints = []
+        detPolPoints = []
+        gtDontCarePolsNum = [] #Array of Ground Truth Polygons' keys marked as don't Care
+        detDontCarePolsNum = [] #Array of Detected Polygons' matched with a don't Care GT
+        detMatchedNums = []
+        pairs = []
+
+        arrSampleConfidences = [];
+        arrSampleMatch = [];
+        sampleAP = 0;
+
+        evaluationLog = ""
+
+        pointsList,_,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(gtFile,evaluationParams['CRLF'],evaluationParams['LTRB'],True,False)
+        for n in range(len(pointsList)):
+            points = pointsList[n]
+            transcription = transcriptionsList[n]
+            dontCare = transcription == "###"
+            if evaluationParams['LTRB']:
+                gtRect = Rectangle(*points)
+                gtPol = rectangle_to_polygon(gtRect)
+            else:
+                gtPol = polygon_from_points(points)
+            gtPols.append(gtPol)
+            gtPolPoints.append(points)
+
+            #On word spotting we will filter some transcriptions with special characters
+            if evaluationParams['WORD_SPOTTING'] :
+                if dontCare == False :
+                    if include_in_dictionary(transcription) == False :
+                        dontCare = True
+                    else:
+                        transcription = include_in_dictionary_transcription(transcription)
+
+            gtTrans.append(transcription)
+            if dontCare:
+                gtDontCarePolsNum.append( len(gtPols)-1 )
+
+        evaluationLog += "GT polygons: " + str(len(gtPols)) + (" (" + str(len(gtDontCarePolsNum)) + " don't care)\n" if len(gtDontCarePolsNum)>0 else "\n")
+
+        if resFile in subm:
+
+            detFile = rrc_evaluation_funcs.decode_utf8(subm[resFile])
+
+            pointsList,confidencesList,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(detFile,evaluationParams['CRLF'],evaluationParams['LTRB'],True,evaluationParams['CONFIDENCES'])
+
+            for n in range(len(pointsList)):
+                points = pointsList[n]
+                transcription = transcriptionsList[n]
+
+                if evaluationParams['LTRB']:
+                    detRect = Rectangle(*points)
+                    detPol = rectangle_to_polygon(detRect)
+                else:
+                    detPol = polygon_from_points(points)
+                detPols.append(detPol)
+                detPolPoints.append(points)
+                detTrans.append(transcription)
+
+                if len(gtDontCarePolsNum)>0 :
+                    for dontCarePol in gtDontCarePolsNum:
+                        dontCarePol = gtPols[dontCarePol]
+                        intersected_area = get_intersection(dontCarePol,detPol)
+                        pdDimensions = detPol.area()
+                        precision = 0 if pdDimensions == 0 else intersected_area / pdDimensions
+                        if (precision > evaluationParams['AREA_PRECISION_CONSTRAINT'] ):
+                            detDontCarePolsNum.append( len(detPols)-1 )
+                            break
+
+            evaluationLog += "DET polygons: " + str(len(detPols)) + (" (" + str(len(detDontCarePolsNum)) + " don't care)\n" if len(detDontCarePolsNum)>0 else "\n")
+
+            if len(gtPols)>0 and len(detPols)>0:
+                #Calculate IoU and precision matrixs
+                outputShape=[len(gtPols),len(detPols)]
+                iouMat = np.empty(outputShape)
+                gtRectMat = np.zeros(len(gtPols),np.int8)
+                detRectMat = np.zeros(len(detPols),np.int8)
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        pG = gtPols[gtNum]
+                        pD = detPols[detNum]
+                        iouMat[gtNum,detNum] = get_intersection_over_union(pD,pG)
+
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCarePolsNum and detNum not in detDontCarePolsNum :
+                            if iouMat[gtNum,detNum]>evaluationParams['IOU_CONSTRAINT']:
+                                gtRectMat[gtNum] = 1
+                                detRectMat[detNum] = 1
+                                #detection matched only if transcription is equal
+                                if evaluationParams['WORD_SPOTTING']:
+                                    correct = gtTrans[gtNum].upper() == detTrans[detNum].upper()
+                                else:
+                                    correct = transcription_match(gtTrans[gtNum].upper(),detTrans[detNum].upper(),evaluationParams['SPECIAL_CHARACTERS'],evaluationParams['ONLY_REMOVE_FIRST_LAST_CHARACTER'])==True
+                                detCorrect += (1 if correct else 0)
+                                if correct:
+                                    detMatchedNums.append(detNum)
+                                pairs.append({'gt':gtNum,'det':detNum,'correct':correct})
+                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + " trans. correct: " + str(correct) + "\n"
+
+            if evaluationParams['CONFIDENCES']:
+                for detNum in range(len(detPols)):
+                    if detNum not in detDontCarePolsNum :
+                        #we exclude the don't care detections
+                        match = detNum in detMatchedNums
+
+                        arrSampleConfidences.append(confidencesList[detNum])
+                        arrSampleMatch.append(match)
+
+                        arrGlobalConfidences.append(confidencesList[detNum]);
+                        arrGlobalMatches.append(match);
+
+        numGtCare = (len(gtPols) - len(gtDontCarePolsNum))
+        numDetCare = (len(detPols) - len(detDontCarePolsNum))
+        if numGtCare == 0:
+            recall = float(1)
+            precision = float(0) if numDetCare >0 else float(1)
+            sampleAP = precision
+        else:
+            recall = float(detCorrect) / numGtCare
+            precision = 0 if numDetCare==0 else float(detCorrect) / numDetCare
+            if evaluationParams['CONFIDENCES']:
+                sampleAP = compute_ap(arrSampleConfidences, arrSampleMatch, numGtCare )
+
+        hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)
+
+        matchedSum += detCorrect
+        numGlobalCareGt += numGtCare
+        numGlobalCareDet += numDetCare
+
+        perSampleMetrics[resFile] = {
+                                        'precision':precision,
+                                        'recall':recall,
+                                        'hmean':hmean,
+                                        'pairs':pairs,
+                                        'AP':sampleAP,
+                                        'iouMat':[] if len(detPols)>100 else iouMat.tolist(),
+                                        'gtPolPoints':gtPolPoints,
+                                        'detPolPoints':detPolPoints,
+                                        'gtTrans':gtTrans,
+                                        'detTrans':detTrans,
+                                        'gtDontCare':gtDontCarePolsNum,
+                                        'detDontCare':detDontCarePolsNum,
+                                        'evaluationParams': evaluationParams,
+                                        'evaluationLog': evaluationLog
+                                    }
+
+    # Compute AP
+    AP = 0
+    if evaluationParams['CONFIDENCES']:
+        AP = compute_ap(arrGlobalConfidences, arrGlobalMatches, numGlobalCareGt)
+
+    methodRecall = 0 if numGlobalCareGt == 0 else float(matchedSum)/numGlobalCareGt
+    methodPrecision = 0 if numGlobalCareDet == 0 else float(matchedSum)/numGlobalCareDet
+    methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+
+    methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean, 'AP': AP  }
+
+    resDict = {'calculated':True,'Message':'','method': methodMetrics,'per_sample': perSampleMetrics}
+
+
+    return resDict
+
+
+
+if __name__=='__main__':
+
+    rrc_evaluation_funcs.main_evaluation(None,default_evaluation_params,validate_data,evaluate_method)

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_metric.py

@@ -0,0 +1,185 @@
+# flake8: noqa
+import re
+import os
+import ast
+import ipdb
+import shutil
+import zipfile
+import subprocess
+import vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.rrc_evaluation_funcs_1_1 as rrc_evaluation_funcs
+from vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.script import default_evaluation_params,validate_data,evaluate_method
+
+
+def extract_bounding_boxes_robust(predict_str):
+    """
+    Extract coordinates and text content from the given prediction string,
+    handling potential format issues.
+
+    Args:
+    predict_str (str): Model prediction output as a string.
+
+    Returns:
+    list: Extracted data in the format [[x1, y1, x2, y2, text_content], ...].
+          Returns None if no valid data is extracted.
+    """
+    results = []
+    seen = set()
+
+    # try parsing with ast.literal_eval
+    try:
+        data = ast.literal_eval(predict_str)
+    except Exception:
+        data = None
+
+    if data is not None:
+        if isinstance(data, (list, tuple)):
+            for item in data:
+                if isinstance(item, (list, tuple)) and len(item) >= 5:
+                    x1_str, y1_str, x2_str, y2_str = item[:4]
+                    text_content = item[4]
+
+                    x1_str = str(x1_str).strip()
+                    y1_str = str(y1_str).strip()
+                    x2_str = str(x2_str).strip()
+                    y2_str = str(y2_str).strip()
+                    text_content = str(text_content).replace("\n", "").strip().strip('"').strip("'")
+
+                    try:
+                        x1 = int(x1_str)
+                        y1 = int(y1_str)
+                        x2 = int(x2_str)
+                        y2 = int(y2_str)
+
+                        if not (0 <= x1 <= 1000 and 0 <= y1 <= 1000 and 0 <= x2 <= 1000 and 0 <= y2 <= 1000):
+                            continue
+
+                        key = (x1, y1, x2, y2, text_content)
+                        if key in seen:
+                            continue
+
+                        seen.add(key)
+                        results.append([x1, y1, x2, y2, text_content])
+                    except ValueError:
+                        continue
+    else:
+        # try parsing with regular expression
+
+        list_content = predict_str
+        items = re.findall(r'[\[\(]\s*([^\[\]\(\)]*?)\s*[\]\)]', list_content)
+
+        if not items:
+            return None
+
+        for item in items:
+            parts = item.split(',', 4)
+            if len(parts) < 5:
+                continue
+
+            x1_str, y1_str, x2_str, y2_str, text_content = parts
+
+            x1_str = x1_str.strip()
+            y1_str = y1_str.strip()
+            x2_str = x2_str.strip()
+            y2_str = y2_str.strip()
+            text_content = text_content.replace("\n", "").strip().strip('"').strip("'")
+
+            try:
+                x1 = int(x1_str)
+                y1 = int(y1_str)
+                x2 = int(x2_str)
+                y2 = int(y2_str)
+
+                if not (0 <= x1 <= 1000 and 0 <= y1 <= 1000 and 0 <= x2 <= 1000 and 0 <= y2 <= 1000):
+                    continue
+
+                key = (x1, y1, x2, y2, text_content)
+                if key in seen:
+                    continue
+
+                seen.add(key)
+                results.append([x1, y1, x2, y2, text_content])
+            except ValueError:
+                continue
+
+    if not results:
+        return None
+
+    return results
+
+
+def zip_folder(source_folder, destination_zip):
+    abs_source = os.path.abspath(source_folder)
+    abs_destination = os.path.abspath(destination_zip)
+
+    with zipfile.ZipFile(abs_destination, 'w', zipfile.ZIP_DEFLATED) as zf:
+        for root, _, files in os.walk(abs_source):
+            for file in files:
+                abs_file_path = os.path.join(root, file)
+
+                relative_path = os.path.relpath(abs_file_path, abs_source)
+                zf.write(abs_file_path, relative_path)
+
+
+def spotting_evaluation(prediction_list, img_metas):
+    score = 0
+
+    submit_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/submit"
+    gt_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/gt"
+    submit_zip_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/submit.zip"
+    gt_zip_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/gt.zip"
+    for file_path in [submit_path, gt_path, submit_zip_path, gt_zip_path]:
+        if "zip" in file_path:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        else:
+            if os.path.exists(file_path):
+                shutil.rmtree(file_path)
+            os.makedirs(file_path)
+
+    res_submit_list = []
+    for item in prediction_list:
+        if len(item) != 5:
+            ipdb.set_trace()
+        x1, y1, x2, y2, rec = item
+        if x1 >= x2 or y1 >= y2:
+            continue
+
+        res_submit_list.append(",".join([str(x1),str(y1),str(x2),str(y1),str(x2),str(y2),str(x1),str(y2),rec]))
+
+    res_gt_list = []
+    for bbox, rec in zip(img_metas["bbox"], img_metas["content"]):
+        x_coords = bbox[0::2]
+        y_coords = bbox[1::2]
+
+        x1, y1 = min(x_coords), min(y_coords)
+        x2, y2 = max(x_coords), max(y_coords)
+
+        res_gt_list.append(",".join([str(x1),str(y1),str(x2),str(y1),str(x2),str(y2),str(x1),str(y2),rec]))
+
+    if len(res_submit_list) == 0 or len(res_gt_list) == 0:
+        return 0
+
+    with open(os.path.join(submit_path,"res_img_0.txt"), "w") as f:
+        for item in res_submit_list[:-1]:
+            f.write(item + "\n")
+        f.write(res_submit_list[-1])
+
+    with open(os.path.join(gt_path,"gt_img_0.txt"), "w") as f:
+        for item in res_gt_list[:-1]:
+            f.write(item + "\n")
+        f.write(res_gt_list[-1])
+
+    zip_folder(submit_path, submit_zip_path)
+    zip_folder(gt_path, gt_zip_path)
+
+    command = {
+        'g': gt_zip_path,
+        's': submit_zip_path,
+        'o': './',
+        'p': '{"IOU_CONSTRAINT":0.5}'
+    }
+
+    # run rrc_evaluation_funcs
+    result = rrc_evaluation_funcs.main_evaluation(command,default_evaluation_params,validate_data,evaluate_method)
+    score = result["method"]["hmean"]
+    return score

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/vqa_metric.py

@@ -0,0 +1,282 @@
+import re
+import os
+import json
+import ipdb
+import math
+import numpy as np
+
+
+def levenshtein_distance(s1, s2):
+    if len(s1) > len(s2):
+        s1, s2 = s2, s1
+
+    distances = range(len(s1) + 1)
+    for i2, c2 in enumerate(s2):
+        distances_ = [i2 + 1]
+        for i1, c1 in enumerate(s1):
+            if c1 == c2:
+                distances_.append(distances[i1])
+            else:
+                distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+        distances = distances_
+    return distances[-1]
+
+
+def vqa_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].lower().strip().replace("\n"," ")
+            except:
+                ipdb.set_trace()
+            if isinstance(predict, (int, float)):
+                predict = str(predict)
+            predict = predict.lower().strip().replace("\n"," ")
+            if len(answer.split()) < 5:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ")
+        predict = predict.lower().strip().replace("\n"," ")
+        if len(answers.split()) < 5:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def cn_vqa_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].lower().strip().replace("\n"," ").replace(" ", "")
+            except:
+                ipdb.set_trace()
+            if isinstance(predict, (int, float)):
+                predict = str(predict)
+            predict = predict.lower().strip().replace("\n"," ").replace(" ", "")
+            if len(answer.split(",")) < 4:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ").replace(" ", "")
+        predict = predict.lower().strip().replace("\n"," ").replace(" ", "")
+        if len(answer.split(",")) < 4:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def vqa_evaluation_case_sensitive(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].strip().replace("\n"," ")
+            except:
+                ipdb.set_trace()
+            predict = predict.strip().replace("\n"," ")
+            if len(answer.split()) < 5:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.strip().replace("\n"," ")
+        predict = predict.strip().replace("\n"," ")
+        if len(answers.split()) < 5:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def extract_first_number(string):
+    match = re.search(r'\d+', string)
+    if match:
+        return int(match.group())
+    return None
+
+
+def counting_evaluation(predict, answers, eval_method):
+    score = 0
+
+    if isinstance(predict, str):
+        predict_processed = predict.lower().strip().replace("\n", " ")
+    elif math.isnan(predict):
+        return 0
+    else:
+        predict_processed = int(predict)
+    if isinstance(answers, list):
+        temp_score = 0
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            answer = answers[j].lower().strip().replace("\n"," ")
+            if eval_method == "exact match":
+                if answer in predict:
+                    score = 1
+                else:
+                    score = 0
+            elif eval_method == "regression":
+                predict_number = extract_first_number(predict_processed)
+                if predict_number:
+
+                    answer = int(answer)
+
+                    if predict_number <= 0 or predict_number >= 2 * answer:
+                        score = 0
+                    else:
+                        iou = 1 - abs(predict_number - answer) / answer
+                        if iou > 0.5:
+                            score = iou
+                        else:
+                            score = 0
+                else:
+                    score = 0
+            if score > temp_score:
+                temp_score = score
+        score = temp_score
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ")
+        predict = predict.lower().strip().replace("\n"," ")
+        if eval_method == "exact match":
+            if answer in predict:
+                score = 1
+            else:
+                score = 0
+        elif eval_method == "regression":
+            predict = extract_first_number(predict)
+            if predict:
+                answer = int(answer)
+                if predict <= 0 or predict >= 2 * answer:
+                    score = 0
+                else:
+                    iou = 1 - abs(predict - answer) / answer
+
+                    if iou > 0.5:
+                        score = iou
+                    else:
+                        score = 0
+            else:
+                score = 0
+    return score
+
+
+def math_expression_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            answer = answers[j].strip().replace("\n"," ").replace(" ","")
+            predict = predict.strip().replace("\n"," ").replace(" ","")
+            if answer in predict:
+                score = 1
+    else:
+        answers = answers.strip().replace("\n"," ").replace(" ","")
+        predict = predict.strip().replace("\n"," ").replace(" ","")
+        if answers in predict:
+            score = 1
+    return score
+
+
+def remove_text_tags(latex_str):
+    """
+    Removes LaTeX \text{...} tags while keeping their content.
+
+    :param latex_str: A string containing LaTeX expressions
+    :return: The processed string with \text{...} tags removed
+    """
+
+    pattern = r'\\text\{([^{}]*)\}'
+
+    processed_str = re.sub(pattern, r'\1', latex_str)
+
+    return processed_str
+
+
+def cn_math_expression_evaluation(predict, answers):
+    score = 0
+
+    assert len(answers) == 1
+    answers = [remove_text_tags(answers[0])]
+    predict = remove_text_tags(predict)
+
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            answer = answers[j].strip().replace("\n"," ").replace(" ","")
+            predict = predict.strip().replace("\n"," ").replace(" ","")
+            if answer in predict:
+                score = 1
+    else:
+        answers = answers.strip().replace("\n"," ").replace(" ","")
+        predict = predict.strip().replace("\n"," ").replace(" ","")
+        if answers in predict:
+            score = 1
+    return score
+
+
+if __name__ == "__main__":
+    test_predict = "apple pie and banana"
+    test_answers = ["apple", "banana pie", "apple pie and orange"]
+
+    vqa_score = vqa_evaluation(test_predict, test_answers)
+    print(f"VQA evaluation score for predict '{test_predict}' and answers {test_answers}: {vqa_score}")

VLMEvalKit-sudoku/vlmeval/dataset/utils/cgbench.py

@@ -0,0 +1,620 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import pandas as pd
+import numpy as np
+import re
+import zipfile
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+frame_tmpl = "frame-{}-of-{}.jpg"
+
+sys_prompt_open_eval_step_1 = (
+    "You will be provided with a question, a model's prediction, and the ground "
+    "truth answer for this question.\n"
+    "Your task is to judge whether the model's prediction is correct based on the "
+    "meaning of the two texts.\n"
+    "In most cases, this can be done by determining if the meaning of the model's "
+    "prediction is consistent with, or contains, the ground truth answer. However, "
+    "in some cases where the two texts differ, it may represent different "
+    "descriptions of the same visual scene, in which case visual information is "
+    "needed for further judgment.\n"
+    "Therefore, I hope you:\n"
+    "- Output 0, if the model's prediction and the ground truth answer are neither "
+    "consistent nor related by inclusion, with fundamentally different meanings.\n"
+    "- Output 1, if the meaning of the model's prediction and the ground truth "
+    "answer is consistent, or if the model's prediction meaningfully contains the "
+    "ground truth answer.\n"
+    "- Output 2, if the model's prediction and ground truth are not consistent or "
+    "inclusive, but may be different descriptions of the same visual scene, "
+    "requiring visual information for further judgment.\n"
+    "Only output the answer in the following format:\n\n"
+    '```json\n{"result": choice}\n```\n\n'
+    "The choice is either 0, 1, or 2 as specified above."
+)
+
+sys_prompt_open_eval_step_2 = (
+    "You will be provided with a question, a model's prediction, and the sampling "
+    "frames of the clue intervals related to this question.\n"
+    "Your task is to determine whether the model has answered the question "
+    "correctly based on the visual information provided.\n"
+    "Therefore, I hope you:\n"
+    "- Output 0, if the model's prediction does not correctly answer the question.\n"
+    "- Output 1, if the model's prediction correctly answers the question.\n"
+    "Only output the answer in the following format without output extra "
+    "explanation:\n\n"
+    '```json\n{"result": choice}\n```\n\n'
+    "The choice is either 0 or 1 as specified above."
+)
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+# '10-20', '20-30', '30-40', '40-50', '50-60'
+DURATIONS = ["0 ~ 10", "10 ~ 20", "20 ~ 30", "30 ~ 40", "40 ~ 50", "50 ~ 60", "60+"]
+
+DOMAINS = [
+    "Life Record",
+    "Music & TV show",
+    "Instruction & Knowledge",
+    "Driving",
+    "Embodied Expert",
+    "Humor/funny",
+    "Electonic/Social Gaming",
+    "Security & Health",
+    "Sports & Exercise",
+    "Special Scenes",
+    "Art & Culture",
+    "GUI",
+    "News",
+    "Animal & Pet",
+]
+
+SUB_CATEGORIES = [
+    "Time Cognition",
+    "Hallucination",
+    "Entity Perception",
+    "2D Spatial Perception",
+    "Time Perception",
+    "Scene Perception",
+    "Text Perception",
+    "Event Cognition",
+    "Entity Cognition",
+    "Text Cognition",
+    "Event Perception",
+    "Scene Cognition",
+]
+
+
+def get_dimention_rating_open_ended(data_path):
+    # 读取数据
+    df = load(data_path)
+
+    df = df[df["score"] != -1]
+
+    # 将秒转换为分钟并分配到对应区间
+    df["duration_minutes"] = df["duration"] / 60
+    df["duration_range"] = pd.cut(
+        df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+    )
+
+    # 初始化结果字典
+    result = {
+        "overall": 0,
+        "duration": {k: 0 for k in DURATIONS},
+        "domain": {k: 0 for k in DOMAINS},
+        "sub_category": {k: 0 for k in SUB_CATEGORIES},
+    }
+
+    # Overall
+    result["overall"] = round(df["score"].mean(), 4)
+
+    # Duration
+    for dur in DURATIONS:
+        dur_scores = df[df["duration_range"] == dur]["score"]
+        result["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+    # Domain
+    for domain in DOMAINS:
+        domain_scores = df[df["domain"] == domain]["score"]
+        result["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+    # Sub-category
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_scores = df[df["sub_category"] == sub_cat]["score"]
+        result["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+    return result
+
+
+def get_dimention_rating_mcq_grouding(data_path):
+
+    # 读取数据
+    df = load(data_path)
+
+    # df.loc[(df['task_mode'] == 'miou') & (df['score'] == -1), 'score'] = 0
+
+    df = df[df["score"] != -1]
+
+    # 将秒转换为分钟并分配到对应区间
+    df["duration_minutes"] = df["duration"] / 60
+    df["duration_range"] = pd.cut(
+        df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+    )
+
+    # 初始化结果字典
+    result = {
+        metric: {
+            "overall": 0,
+            "duration": {k: 0 for k in DURATIONS},
+            "domain": {k: 0 for k in DOMAINS},
+            "sub_category": {k: 0 for k in SUB_CATEGORIES},
+        }
+        for metric in ["long_acc", "clue_acc", "miou", "CRR", "acc@iou", "rec@iou"]
+    }
+
+    # 计算基础指标
+    for metric in ["long_acc", "clue_acc", "miou"]:
+        metric_df = df[df["task_mode"] == metric]
+
+        # Overall
+        result[metric]["overall"] = round(metric_df["score"].mean(), 4)
+
+        # Duration
+        for dur in DURATIONS:
+            dur_scores = metric_df[metric_df["duration_range"] == dur]["score"]
+            result[metric]["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+        # Domain
+        for domain in DOMAINS:
+            domain_scores = metric_df[metric_df["domain"] == domain]["score"]
+            result[metric]["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+        # Sub-category
+        for sub_cat in SUB_CATEGORIES:
+            sub_cat_scores = metric_df[metric_df["sub_category"] == sub_cat]["score"]
+            result[metric]["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+    # 计算复合指标 CRR
+    def calculate_crr(scores):
+        long_acc = scores[scores["task_mode"] == "long_acc"]["score"].mean()
+        clue_acc = scores[scores["task_mode"] == "clue_acc"]["score"].mean()
+        return round(min(long_acc, clue_acc) / clue_acc, 4) if clue_acc != 0 else 0
+
+    # Overall CRR
+    result["CRR"]["overall"] = calculate_crr(df)
+
+    # Duration CRR
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["CRR"]["duration"][dur] = calculate_crr(dur_df)
+
+    # Domain CRR
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["CRR"]["domain"][domain] = calculate_crr(domain_df)
+
+    # Sub-category CRR
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["CRR"]["sub_category"][sub_cat] = calculate_crr(sub_cat_df)
+
+    # 计算 acc@iou
+    def calculate_acc_at_iou_threshold(scores, threshold):
+
+        miou_qids = set(scores[scores["task_mode"] == "miou"]["qid"])
+
+        long_acc_qids = set(scores[scores["task_mode"] == "long_acc"]["qid"])
+
+        valid_qids = miou_qids & long_acc_qids
+
+        miou_positive = set(scores[(scores["task_mode"] == "miou") & (scores["score"] > threshold)]["qid"])
+
+        long_acc_positive = scores[
+            (scores["task_mode"] == "long_acc") & (scores["qid"].isin(miou_positive)) & (scores["score"] == 1)
+        ]
+
+        acc_at_iou_threshold = len(long_acc_positive) / len(valid_qids) if len(valid_qids) > 0 else 0
+        return round(acc_at_iou_threshold, 4)
+
+    def calculate_acc_at_iou(scores):
+        thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+        acc_at_iou_values = [calculate_acc_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+        return round(sum(acc_at_iou_values) / len(acc_at_iou_values), 4)
+
+    # Overall acc@iou
+    result["acc@iou"]["overall"] = calculate_acc_at_iou(df)
+
+    # Duration acc@iou
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["acc@iou"]["duration"][dur] = calculate_acc_at_iou(dur_df)
+
+    # Domain acc@iou
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["acc@iou"]["domain"][domain] = calculate_acc_at_iou(domain_df)
+
+    # Sub-category acc@iou
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["acc@iou"]["sub_category"][sub_cat] = calculate_acc_at_iou(sub_cat_df)
+
+    # 计算 rec@iou
+    def calculate_rec_at_iou_threshold(scores, threshold):
+        # 获取所有 miou 类型的数据
+        miou_scores = scores[scores["task_mode"] == "miou"]
+
+        # 计算 miou score 大于 threshold 的数量
+        miou_positive = miou_scores[miou_scores["score"] > threshold]
+
+        # 计算比例
+        rec_at_iou = len(miou_positive) / len(miou_scores) if len(miou_scores) > 0 else 0
+
+        return round(rec_at_iou, 4)
+
+    def calculate_rec_at_iou(scores):
+        thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+        rec_at_iou_values = [calculate_rec_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+        return round(sum(rec_at_iou_values) / len(rec_at_iou_values), 4)
+
+    # Overall rec@iou
+    result["rec@iou"]["overall"] = calculate_rec_at_iou(df)
+
+    # Duration rec@iou
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["rec@iou"]["duration"][dur] = calculate_rec_at_iou(dur_df)
+
+    # Domain rec@iou
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["rec@iou"]["domain"][domain] = calculate_rec_at_iou(domain_df)
+
+    # Sub-category rec@iou
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["rec@iou"]["sub_category"][sub_cat] = calculate_rec_at_iou(sub_cat_df)
+
+    return result
+
+
+def milliseconds_to_seconds(milliseconds):
+    return milliseconds / 1000
+
+
+def sample_frames_clue_average(clues_time_intervals, frame_num, fps):
+    # 计算每个线索区间的时长
+    clues_frame_intervals = [(round(interval[0] * fps), round(interval[1] * fps)) for interval in clues_time_intervals]
+    clue_durations = [interval[1] - interval[0] for interval in clues_frame_intervals]
+    total_duration = sum(clue_durations)
+    # 如果 frame_num 的数量大于等于总帧数, 则直接返回全部帧
+    if frame_num >= total_duration:
+        return [frame for interval in clues_frame_intervals for frame in range(interval[0], interval[1])]
+    frames_per_clue = [int(frame_num * (duration / total_duration)) for duration in clue_durations]
+    frame_indices = []
+    for i, (interval, num_frames) in enumerate(zip(clues_frame_intervals, frames_per_clue)):
+        num_frames = max(1, num_frames)
+        seg_size = (interval[1] - interval[0]) / num_frames
+        clue_frame_indices = [int(interval[0] + seg_size / 2 + seg_size * idx) for idx in range(num_frames)]
+        frame_indices.extend(clue_frame_indices)
+    return frame_indices
+
+
+def merge_intervals(intervals):
+    """
+    Merge overlapping intervals in a list.
+    Assumes each interval is a list [start, end].
+    """
+    if not intervals:
+        return []
+
+    # Sort intervals by start time
+    intervals.sort(key=lambda x: x[0])
+
+    merged = [intervals[0]]
+
+    for current in intervals[1:]:
+        last_merged = merged[-1]
+
+        # Check if there is an overlap
+        if current[0] <= last_merged[1]:
+            # Merge the current interval with the last one
+            last_merged[1] = max(last_merged[1], current[1])
+        else:
+            # No overlap, add current interval
+            merged.append(current)
+
+    return merged
+
+
+def calculate_intervals_iou(intervals1, intervals2):
+    """
+    Calculate the IoU of two lists of intervals.
+    Each list contains intervals represented as [start, end].
+    """
+    # Merge overlapping intervals in both lists
+    merged1 = merge_intervals(intervals1)
+    merged2 = merge_intervals(intervals2)
+
+    # Calculate total length of intervals for both lists
+    def total_length(merged_intervals):
+        return sum(end - start for start, end in merged_intervals)
+
+    length1 = total_length(merged1)
+    length2 = total_length(merged2)
+
+    # Calculate intersection length
+    intersection_length = 0
+    for interval1 in merged1:
+        for interval2 in merged2:
+            intersection_start = max(interval1[0], interval2[0])
+            intersection_end = min(interval1[1], interval2[1])
+            intersection_length += max(0, intersection_end - intersection_start)
+    # Calculate union length
+    union_length = length1 + length2 - intersection_length
+    # IoU is intersection divided by union
+    iou = intersection_length / union_length if union_length > 0 else 0
+    return iou
+
+
+def post_process(response, right_answer, task_mode, duration):
+    result = -1
+
+    if response:
+        # 找到 ```json 和 ``` 的位置
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        # 如果找到了 json 内容
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            if task_mode in ["long_acc", "clue_acc"]:
+                json_content = re.sub(r"(?<=:\s)([A-Za-z_]\w*)", r'"\1"', json_content)
+
+            try:
+                model_result = json.loads(json_content)["result"]
+
+                if task_mode in ["long_acc", "clue_acc"]:
+                    result = 1 if right_answer == model_result else 0
+                elif task_mode == "miou":
+                    if not isinstance(model_result, list):
+                        return -1
+                    if not isinstance(model_result[0], list):
+                        model_result = [model_result]
+
+                    need_duration = all(interval[0] <= 1 and interval[1] <= 1 for interval in model_result)
+
+                    if need_duration:
+                        model_result = [[interval[0] * duration, interval[1] * duration] for interval in model_result]
+
+                    right_answer = eval(right_answer)
+
+                    result = calculate_intervals_iou(right_answer, model_result)
+
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+
+        if result == -1:
+            if task_mode in ["long_acc", "clue_acc"]:
+                # 检查是否存在大写字母 A-H，认为其为模型答案
+                matches = re.findall(r"\b[A-H]\b", response)
+                if matches:
+                    result = 1 if right_answer in matches else 0
+            elif task_mode == "miou":
+                # 提取所有实数，进行配对
+                numbers = re.findall(r"-?\d+\.?\d*", response)
+                if len(numbers) < 2:
+                    result = -1
+                else:
+                    if len(numbers) % 2 != 0:
+                        numbers = numbers[:-1]
+                    model_result = [[float(numbers[i]), float(numbers[i + 1])] for i in range(0, len(numbers), 2)]
+
+                    if type(right_answer) is str:
+                        right_answer = eval(right_answer)
+
+                    result = calculate_intervals_iou(right_answer, model_result)
+
+    return result
+
+
+def get_timestampes(frame_indices, fps):
+    seconds = list(map(lambda x: str(round(x / fps, 4)), frame_indices))
+    timestamps = ", ".join(seconds)
+    return "A total of {frame_num} frames are sampled. Their corresponding timestamps are:\n\n{timestamps}\n\n".format(
+        frame_num=len(frame_indices), timestamps=timestamps
+    )
+
+
+def post_process_open(response):
+    model_result = -1
+
+    if response and response != FAIL_MSG:
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        # 如果找到了 json 内容
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            try:
+                model_result = json.loads(json_content)["result"]
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+
+        if model_result == -1:
+            model_result = response
+
+    return model_result
+
+
+def post_process_eval_open(response, step):
+
+    model_result = -1
+
+    if response and response != FAIL_MSG:
+
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            try:
+                model_result = json.loads(json_content)["result"]
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+                return -1
+        if model_result == -1:
+            if step == 1:
+                match = re.search(r"[012]", response)
+                if match:
+                    model_result = int(match.group())
+            else:
+                match = re.search(r"[01]", response)
+                if match:
+                    model_result = int(match.group())
+
+    return model_result
+
+
+def eval_open_first(model, line):
+
+    user_prompt = ""
+
+    user_prompt += f"Question: {line['question']}\n\n"
+
+    user_prompt += f"The ground truth answer is '{line['answer']}'\n\n"
+
+    user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+    result = model.generate(user_prompt)
+
+    return result
+
+
+def save_step_1_steps(data, step_1_results):
+
+    # 处理所有结果
+    data["step_1_result"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 1))
+
+    # 条件更新
+    mask = data["step_1_result"].isin([-1, 0, 1])
+    data.loc[mask, "step_2_result"] = data.loc[mask, "step_1_result"]
+    data.loc[mask, "score"] = data.loc[mask, "step_1_result"]
+
+    return data
+
+
+def eval_open_second(model, line, frame_paths):
+
+    user_prompt = ""
+
+    user_prompt += f"Question: {line['question']}\n\n"
+
+    user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+    result = model.generate([user_prompt] + frame_paths)
+
+    return result
+
+
+def save_step_2_steps(data, step_1_results):
+
+    # 处理所有结果
+    data["score"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 2))
+
+    return data
+
+
+def clue_frame_paths(clue_frame_root, qid, num_frames=8):
+    frame_root = osp.join(clue_frame_root, str(qid))
+    os.makedirs(frame_root, exist_ok=True)
+    return [osp.join(frame_root, frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+
+def save_clue_video_frames(data_root, clue_frame_root, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+    if type(uid) is str:
+        uid = str(uid)
+
+    vid_path = osp.join(data_root, video)
+    import decord
+    vid = decord.VideoReader(vid_path)
+    vid_fps = vid.get_avg_fps()
+
+    if clue_intervals is not None:
+        # 1. 合并重叠区间
+        merged_intervals = merge_intervals(clue_intervals)
+
+        if num_frames > 0 and fps < 0:
+            # 2. 基于clue_intervals均匀抽帧
+            indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+            frame_paths = clue_frame_paths(clue_frame_root, uid, len(indices))
+
+    # 保存帧
+    flag = np.all([osp.exists(p) for p in frame_paths])
+    if not flag:
+        lock_path = osp.splitext(vid_path)[0] + '.lock'
+        with portalocker.Lock(lock_path, 'w', timeout=30):
+            if not np.all([osp.exists(p) for p in frame_paths]):
+                images = [vid[i].asnumpy() for i in indices]
+                images = [Image.fromarray(arr) for arr in images]
+                for im, pth in zip(images, frame_paths):
+                    if not osp.exists(pth):
+                        im.save(pth)
+
+    return frame_paths, indices, vid_fps
+
+
+def get_chunk_number(filename):
+    try:
+        num = filename.split("chunk_")[1].split(".zip")[0]
+        return int(num)
+    except:
+        return float('inf')
+
+
+def unzip_hf_zip(target_dir):
+    target_dir = Path(target_dir)
+
+    videos_dir = target_dir / "cg_videos_720p"
+    clue_videos_dir = target_dir / "cg_clue_videos"
+    subtitles_dir = target_dir / "cg_subtitles"
+
+    if videos_dir.exists() and clue_videos_dir.exists() and subtitles_dir.exists():
+        print("all target dirs exist, skip.")
+        return
+
+    videos_dir.mkdir(parents=True, exist_ok=True)
+    clue_videos_dir.mkdir(parents=True, exist_ok=True)
+    subtitles_dir.mkdir(parents=True, exist_ok=True)
+
+    video_zips = sorted(target_dir.glob("video_chunk_*.zip"))
+    for zip_path in tqdm(video_zips, desc="unzip videos"):
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(videos_dir)
+
+    clue_zips = sorted(target_dir.glob("clue_video_chunk_*.zip"))
+    for zip_path in tqdm(clue_zips, desc="unzip clue videos"):
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(clue_videos_dir)
+
+    subtitles_zip = target_dir / "subtitles.zip"
+    with zipfile.ZipFile(subtitles_zip, "r") as zip_ref:
+        for file in tqdm(zip_ref.namelist(), desc="unzip subtitles"):
+            zip_ref.extract(file, subtitles_dir)
+
+    print("sucessfully unzip all files.")

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/global_config.py

@@ -0,0 +1,61 @@
+import subprocess
+texts = []
+images = []
+markers = []
+
+
+def reset_texts():
+    texts.clear()
+
+
+def add_text(text):
+    texts.append(text)
+
+
+def get_raw_texts():
+    return [item[2] for item in texts]
+
+
+def get_texts():
+    return texts
+
+
+def reset_images():
+    images.clear()
+
+
+def add_image(image):
+    images.append(image)
+
+
+def get_images():
+    return images
+
+
+def reset_markers():
+    markers.clear()
+
+
+def add_marker(marker):
+    markers.append(marker)
+
+
+def get_markers():
+    return markers
+
+
+def run_script_safe(script_path):
+    try:
+        subprocess.run(
+            ["python3", script_path],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        return True  # success
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] Failed to run {script_path}")
+        print(f"[Return Code]: {e.returncode}")
+        print(f"[Stdout]:\n{e.stdout}")
+        print(f"[Stderr]:\n{e.stderr}")
+        return False  # failed

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_evaluator_prefix.py

@@ -0,0 +1,372 @@
+import os
+import sys
+# sys.path.insert(0, os.environ['PROJECT_PATH'])
+if os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] not in sys.path:
+    sys.path.insert(0, os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"])
+
+from matplotlib.projections.polar import PolarAxes
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.axes._base import _process_plot_var_args
+import squarify
+import networkx.drawing.nx_pylab as nx_pylab
+import networkx as nx
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.image import NonUniformImage
+from matplotlib.patches import Ellipse, Circle
+from matplotlib.tri._tripcolor import tripcolor
+from matplotlib_venn._common import VennDiagram
+import inspect
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+# sys.path.insert(0, os.environ['PROJECT_PATH'])
+
+called_functions = {}
+in_decorator = False
+
+
+def log_function_specific_for_draw_networkx_labels(func):
+    def wrapper(
+        G,
+        pos,
+        labels=None,
+        font_size=12,
+        font_color="k",
+        font_family="sans-serif",
+        font_weight="normal",
+        alpha=None,
+        bbox=None,
+        horizontalalignment="center",
+        verticalalignment="center",
+        ax=None,
+        clip_on=True,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_edges(func):
+    def wrapper(
+        G,
+        pos,
+        edgelist=None,
+        width=1.0,
+        edge_color="k",
+        style="solid",
+        alpha=None,
+        arrowstyle=None,
+        arrowsize=10,
+        edge_cmap=None,
+        edge_vmin=None,
+        edge_vmax=None,
+        ax=None,
+        arrows=None,
+        label=None,
+        node_size=300,
+        nodelist=None,
+        node_shape="o",
+        connectionstyle="arc3",
+        min_source_margin=0,
+        min_target_margin=0,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_nodes(func):
+    def wrapper(
+        G,
+        pos,
+        nodelist=None,
+        node_size=300,
+        node_color="#1f78b4",
+        node_shape="o",
+        alpha=None,
+        cmap=None,
+        vmin=None,
+        vmax=None,
+        ax=None,
+        linewidths=None,
+        edgecolors=None,
+        label=None,
+        margins=None,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global in_decorator
+        if not in_decorator:
+            in_decorator = True
+            if len(args) > 0 and isinstance(
+                    args[0], PolarAxes) and func.__name__ == "plot":
+                file_name = inspect.getfile(func)
+                file_name += "_polar"
+            else:
+                file_name = inspect.getfile(func)
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+            result = func(*args, **kwargs)
+            in_decorator = False
+            return result
+        else:
+            return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+Axes.bar = log_function(Axes.bar)
+Axes.barh = log_function(Axes.barh)   # The same as the bar
+
+# _process_plot_var_args._makeline = log_function(_process_plot_var_args._makeline)
+Axes.plot = log_function(Axes.plot)     # Special Case for polar plot
+Axes.axhline = log_function(Axes.axhline)
+Axes.axvline = log_function(Axes.axvline)
+Axes.axvspan = log_function(Axes.axvspan)
+Axes.axhspan = log_function(Axes.axhspan)
+Axes.hlines = log_function(Axes.hlines)
+Axes.vlines = log_function(Axes.vlines)
+
+Axes.errorbar = log_function(Axes.errorbar)   # The same as the line
+
+Axes.boxplot = log_function(Axes.boxplot)
+
+Axes.violinplot = log_function(Axes.violinplot)
+Axes.violin = log_function(Axes.violin)
+
+Axes.hist = log_function(Axes.hist)
+
+# Axes._fill_between_x_or_y = log_function(Axes._fill_between_x_or_y)
+Axes.fill_between = log_function(Axes.fill_between)
+Axes.fill_betweenx = log_function(Axes.fill_betweenx)
+
+Axes.scatter = log_function(Axes.scatter)
+
+nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx_pylab.draw_networkx_nodes)
+nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx_pylab.draw_networkx_edges)
+nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx_pylab.draw_networkx_labels)
+
+# nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(nx_pylab.draw_networkx_nodes)
+# nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(nx_pylab.draw_networkx_edges)
+# nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(nx_pylab.draw_networkx_labels)
+
+nx.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx.draw_networkx_nodes)
+nx.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx.draw_networkx_edges)
+nx.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx.draw_networkx_labels)
+
+Axes.quiver = log_function(Axes.quiver)
+
+Axes3D.scatter = log_function(Axes3D.scatter)
+Axes3D.plot = log_function(Axes3D.plot)
+Axes3D.plot_surface = log_function(Axes3D.plot_surface)
+Axes3D.bar3d = log_function(Axes3D.bar3d)
+Axes3D.bar = log_function(Axes3D.bar)
+Axes3D.add_collection3d = log_function(Axes3D.add_collection3d)
+
+Axes.pie = log_function(Axes.pie)
+
+Axes.fill = log_function(Axes.fill)
+
+squarify.plot = log_function(squarify.plot)
+
+Axes.imshow = log_function(Axes.imshow)
+Axes.pcolor = log_function(Axes.pcolor)
+NonUniformImage.__init__ = log_function(NonUniformImage.__init__)
+
+Axes.contour = log_function(Axes.contour)
+Axes.contourf = log_function(Axes.contourf)
+
+Ellipse.__init__ = log_function(Ellipse.__init__)
+Axes.broken_barh = log_function(Axes.broken_barh)
+
+Axes.tripcolor = log_function(Axes.tripcolor)
+
+VennDiagram.__init__ = log_function(VennDiagram.__init__)
+
+Circle.__init__ = log_function(Circle.__init__)
+
+# Axes.plot = log_function(Axes.plot)
+# Axes.loglog = log_function(Axes.loglog)
+# Axes.scatter = log_function(Axes.scatter)
+# Axes.bar = log_function(Axes.bar)
+# Axes.barh = log_function(Axes.barh)
+# Axes.axhline = log_function(Axes.axhline)
+# Axes.axvline = log_function(Axes.axvline)
+# Axes.errorbar = log_function(Axes.errorbar)
+# Axes.matshow = log_function(Axes.matshow)
+# Axes.hist = log_function(Axes.hist)
+# Axes.pie = log_function(Axes.pie)
+# Axes.boxplot = log_function(Axes.boxplot)
+# Axes.arrow = log_function(Axes.arrow)
+# Axes.fill_between = log_function(Axes.fill_between)
+# Axes.fill_betweenx = log_function(Axes.fill_betweenx)
+# Axes.imshow = log_function(Axes.imshow)
+# Axes.contour = log_function(Axes.contour)
+# Axes.contourf = log_function(Axes.contourf)
+# Axes.violinplot = log_function(Axes.violinplot)
+# Axes.violin = log_function(Axes.violin)
+
+# squarify.plot = log_function(squarify.plot)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator.py

@@ -0,0 +1,326 @@
+# flake8: noqa
+from typing import List, Tuple
+
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+# from skimage.color import deltaE_cie76
+# from skimage.color import rgb2lab
+from itertools import permutations
+from multiprocessing import Pool, cpu_count
+from .color_utils import group_color, calculate_similarity_single
+
+from multiprocessing import Process
+
+
+# def hex_to_rgb(hex_color):
+#     hex_color = hex_color.lstrip('#')
+#     return tuple(int(hex_color[i:i+2], 16) / 255.0 for i in (0, 2, 4))
+
+# def calculate_similarity_single(c1, c2):
+#     c1_file = c1.split("--")[0]
+#     c2_file = c2.split("--")[0]
+
+#     c1_color = c1.split("--")[1]
+#     c2_color = c2.split("--")[1]
+
+#     if c1_file != c2_file:
+#         return 0
+#     elif c1_color.startswith("#") and c2_color.startswith("#"):
+
+#         c1_color = rgb2lab(np.array([hex_to_rgb(c1_color)]))
+#         c2_color = rgb2lab(np.array([hex_to_rgb(c2_color)]))
+
+#         return max(0, 1 - deltaE_cie76(c1_color, c2_color)[0] / 100)
+#     elif not c1_color.startswith("#") and not c2_color.startswith("#"):
+
+#         return 1 if c1_color == c2_color else 0
+#     else:
+#         return 0
+
+
+def calculate_similarity_for_permutation(args):
+    shorter, perm = args
+    current_similarity = sum(
+        calculate_similarity_single(c1, c2) for c1, c2 in zip(shorter, perm)
+    )
+    return current_similarity
+
+
+class ColorEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0,
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        # print("genearion_code_file", generation_code_file)
+        # print("golden_code_file", golden_code_file)
+
+        self.golden_code_file = golden_code_file
+
+        # print(f"generation_code_file: {generation_code_file}")
+        generation_colors = self._log_colors(generation_code_file)
+        # print(f"golden_code_file: {golden_code_file}")
+        golden_colors = self._log_colors(golden_code_file)
+        # print(f"len(generation_colors): {len(generation_colors)}")
+        # print(f"len(golden_colors): {len(golden_colors)}")
+
+        self._calculate_metrics(generation_colors, golden_colors)
+
+        # [TAG] What is this for?
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_colors(self, code_file):
+        """
+        Get text objects of the code
+        """
+
+        with open(code_file, "r") as f:
+            lines = f.readlines()
+        code = "".join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_colors.txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_colors.py")
+        with open(code_log_texts_file, "w") as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, "r") as f:
+                colors = f.read()
+                try:
+                    colors = eval(colors)
+                except BaseException:
+                    colors = []
+            os.remove(output_file)
+        else:
+            colors = []
+
+        os.remove(code_log_texts_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return colors
+
+    def _calculate_metrics(
+        self, generation_colors: List[Tuple], golden_colors: List[Tuple]
+    ):
+        generation_colors = list(generation_colors)
+        golden_colors = list(golden_colors)
+
+        if len(generation_colors) == 0 or len(golden_colors) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        group_generation_colors = group_color(generation_colors)
+        group_golden_colors = group_color(golden_colors)
+
+        # print("group_generation_colors", group_generation_colors)
+        # print("group_golden_colors", group_golden_colors)
+
+        # print("generation_colors", generation_colors)
+        # print("golden_colors", golden_colors)
+
+        def calculate_similarity_serial(lst1, lst2):
+            if len(lst1) == 0 or len(lst2) == 0:
+                return 0
+
+            shorter, longer = (lst1, lst2) if len(lst1) <= len(lst2) else (lst2, lst1)
+
+            max_total_similarity = float("-inf")
+            best_index = None
+
+            for perm in permutations(longer, len(shorter)):
+                current_similarity = sum(
+                    calculate_similarity_single(c1, c2) for c1, c2 in zip(shorter, perm)
+                )
+                current_similarity /= len(shorter)
+
+                if current_similarity > max_total_similarity:
+                    max_total_similarity = current_similarity
+                    best_index = [shorter, perm]
+
+            # best_index[0] = sorted(best_index[0])
+            # best_index[1] = sorted(best_index[1])
+            # print("best_index", best_index)
+            for i1, i2 in zip(best_index[0], best_index[1]):
+                print(i1, i2)
+            tmp_similarity = sum(
+                calculate_similarity_single(c1, c2)
+                for c1, c2 in zip(best_index[0], best_index[1])
+            ) / len(shorter)
+            print("tmp_similarity", tmp_similarity)
+
+            return max_total_similarity
+
+        def calculate_similarity_parallel(lst1, lst2):
+            if len(lst1) == 0 or len(lst2) == 0:
+                return 0
+
+            shorter, longer = (lst1, lst2) if len(lst1) <= len(lst2) else (lst2, lst1)
+            perms = permutations(longer, len(shorter))
+
+            # create processes according to the number of CPUs
+            with Pool(processes=cpu_count()) as pool:
+                similarities = pool.map(
+                    calculate_similarity_for_permutation,
+                    [(shorter, perm) for perm in perms],
+                )
+
+            # print("length of similarities", len(similarities))
+
+            # indexes = [item[0] for item in similarities]
+            # similarities = [item[1] for item in similarities]
+
+            # get max similarity and its index
+            # max_total_similarity = max(similarities)
+            # max_index = similarities.index(max_total_similarity)
+            # index = indexes[max_index]
+
+            # max_total_similarity = max(similarities)
+            # index[0] = sorted(index[0])
+            # index[1] = sorted(index[1])
+            # for i1, i2 in zip(index[0], index[1]):
+            # print(i1, i2)
+
+            # tmp_similarity = sum( calculate_similarity_single(c1, c2) for c1, c2 in zip(index[0], index[1]) ) / len(shorter)
+            # print("tmp_similarity", tmp_similarity)
+            # print("best_index", index)
+
+            return max(similarities)
+
+        # merge keys in group_generation_colors and group_golden_colors
+        merged_color_group = list(
+            set(list(group_generation_colors.keys()) + list(group_golden_colors.keys()))
+        )
+        for color in merged_color_group:
+            if color not in group_generation_colors:
+                group_generation_colors[color] = []
+            if color not in group_golden_colors:
+                group_golden_colors[color] = []
+
+        max_set_similarity = 0
+
+        for color in merged_color_group:
+            max_set_similarity += calculate_similarity_parallel(
+                group_generation_colors[color], group_golden_colors[color]
+            )
+
+        # self.metrics["similarity"] = calculate_similarity_parallel(generation_colors, golden_colors)
+        # max_set_similarity = calculate_similarity_parallel(generation_colors, golden_colors)
+        self.metrics["precision"] = (
+            max_set_similarity / len(generation_colors)
+            if len(generation_colors) != 0
+            else 0
+        )
+        if "box" in self.golden_code_file:
+            self.metrics["recall"] = (
+                max_set_similarity / len(golden_colors)
+                if len(golden_colors) != 0
+                else 0
+            )
+        else:
+            self.metrics["recall"] = max_set_similarity / len(golden_colors)
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = (
+                2
+                * self.metrics["precision"]
+                * self.metrics["recall"]
+                / (self.metrics["precision"] + self.metrics["recall"])
+            )
+
+        return
+
+    def _get_prefix(self):
+        with open(
+            os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+            + "/evaluator/color_evaluator_prefix.py",
+            "r",
+        ) as f:
+            prefix = f.read()
+        return prefix
+
+    def _get_suffix(self, output_file):
+        return f"""
+drawed_colors = list(set(drawed_colors))
+drawed_colors = update_drawed_colors(drawed_objects)
+if len(drawed_colors) > 10:
+    drawed_colors = filter_color(drawed_colors)
+# print("drawed_colors", drawed_colors)
+# print("len(drawed_colors)", len(drawed_colors))
+# print("Length of drawed_obejcts", len(drawed_objects))
+# print("drawed_objects", drawed_objects)
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_colors))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = ColorEvaluator()
+    # evaluator = TextEvaluator()
+
+    golden_code_dir = f"{os.environ['PROJECT_PATH']}/dataset/ori_500/"
+    generation_code_dir = f"{os.environ['PROJECT_PATH']}/results/chart2code_Phi-3-vision-128k-instruct_DirectAgent_results/direct/"
+
+    # list python files in the directory
+    golden_code_files = [f for f in os.listdir(golden_code_dir) if f.endswith(".py")]
+
+    # for golden_code_file in golden_code_files:
+    # print(golden_code_file)
+    # generation_code_file = generation_code_dir + golden_code_file
+    # evaluator(generation_code_file, golden_code_dir + golden_code_file)
+
+    # write a multi-processing version
+    def _muti_process_run(rank, data, num_processes):
+        for i in range(rank, len(data), num_processes):
+            golden_code_file = data[i]
+            generation_code_file = generation_code_dir + golden_code_file
+            evaluator(generation_code_file, golden_code_dir + golden_code_file)
+
+    evaluator = ColorEvaluator()
+    processes = []
+    num_processes = 20
+    for rank in range(num_processes):
+        p = Process(
+            target=_muti_process_run, args=(rank, golden_code_files, num_processes)
+        )
+        p.start()
+        processes.append(p)
+    for p in processes:
+        p.join()
+
+    # golden_code_file = f"{os.environ['PROJECT_PATH']}/dataset/ori_500/line_5.py"
+    # generation_code_file = f"{os.environ['PROJECT_PATH']}/results/chart2code_gpt-4-vision-preview_DirectAgent_results/direct/line_5.py"
+    # evaluator(generation_code_file, golden_code_file)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator_prefix.py

@@ -0,0 +1,835 @@
+# # flake8: noqa
+import os
+import squarify
+
+import warnings
+
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+import sys
+
+if os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] not in sys.path:
+    sys.path.insert(0, os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"])
+
+import networkx
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import networkx as nx
+from matplotlib.axes._base import _process_plot_var_args
+from matplotlib.axes._axes import Axes
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.colors as mcolors
+import networkx.drawing.nx_pylab as nx_pylab
+from matplotlib.projections.polar import PolarAxes
+from matplotlib.image import NonUniformImage
+from matplotlib.patches import Ellipse, Circle
+from matplotlib_venn._common import VennDiagram
+import inspect
+from evaluator.color_utils import filter_color
+# from chart2code.utils.evaluator.color_utils import filter_color
+
+
+drawed_colors = []
+drawed_objects = {}
+in_decorator = False
+
+
+def convert_color_to_hex(color):
+    'Convert color from name, RGBA, or hex to a hex format.'
+    try:
+        # First, try to convert from color name to RGBA to hex
+        if isinstance(color, str):
+            # Check if it's already a hex color (start with '#' and length
+            # either 7 or 9)
+            if color.startswith('#') and (len(color) == 7 or len(color) == 9):
+                return color.upper()
+            else:
+                return mcolors.to_hex(mcolors.to_rgba(color)).upper()
+        # Then, check if it's in RGBA format
+        elif isinstance(color, (list, tuple, np.ndarray)) and (len(color) == 4 or len(color) == 3):
+            return mcolors.to_hex(color).upper()
+        else:
+            raise ValueError("Unsupported color format")
+    except ValueError as e:
+        print(color)
+        print("Error converting color:", e)
+        return None
+
+
+def log_function_specific_for_draw_networkx_labels(func):
+    def wrapper(
+        G,
+        pos,
+        labels=None,
+        font_size=12,
+        font_color="k",
+        font_family="sans-serif",
+        font_weight="normal",
+        alpha=None,
+        bbox=None,
+        horizontalalignment="center",
+        verticalalignment="center",
+        ax=None,
+        clip_on=True,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+
+            for item in result.values():
+                color = convert_color_to_hex(item.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = item
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_edges(func):
+    def wrapper(
+        G,
+        pos,
+        edgelist=None,
+        width=1.0,
+        edge_color="k",
+        style="solid",
+        alpha=None,
+        arrowstyle=None,
+        arrowsize=10,
+        edge_cmap=None,
+        edge_vmin=None,
+        edge_vmax=None,
+        ax=None,
+        arrows=None,
+        label=None,
+        node_size=300,
+        nodelist=None,
+        node_shape="o",
+        connectionstyle="arc3",
+        min_source_margin=0,
+        min_target_margin=0,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+
+            if isinstance(result, list):
+                for line in result:
+                    color = convert_color_to_hex(line.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                if len(result) > 0:
+                    drawed_objects[func_name + "--" + color] = result
+            else:
+                for item in result.get_edgecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+                if len(result.get_edgecolors().tolist()) > 0:
+                    drawed_objects[func_name + "--" +
+                                   color] = result  # ! Attention
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_nodes(func):
+    def wrapper(
+        G,
+        pos,
+        nodelist=None,
+        node_size=300,
+        node_color="#1f78b4",
+        node_shape="o",
+        alpha=None,
+        cmap=None,
+        vmin=None,
+        vmax=None,
+        ax=None,
+        linewidths=None,
+        edgecolors=None,
+        label=None,
+        margins=None,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+
+            for item in result.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+            drawed_objects[func_name + "--" + color] = result
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_for_3d(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "scatter":
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"])
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"].name)
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    for item in result.get_facecolors().tolist():
+                        color = convert_color_to_hex(item)
+                        drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" +
+                                   color] = result  # ! Attention
+            elif func.__name__ == "plot":
+                for line in result:
+                    color = convert_color_to_hex(line.get_color())
+                    drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" + color] = line
+            elif func.__name__ == "plot_surface":
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"])
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"].name)  # ! Attention
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    colors = result.get_facecolors().tolist()
+                    drawed_colors.append(
+                        func_name +
+                        "_3d--" +
+                        convert_color_to_hex(
+                            colors[0]))
+                    # ! Attention
+                    drawed_objects[func_name + "_3d--" +
+                                   convert_color_to_hex(colors[0])] = result
+            elif func.__name__ == "bar3d":
+                colors = result.get_facecolors().tolist()
+                drawed_colors.append(
+                    func_name +
+                    "_3d--" +
+                    convert_color_to_hex(
+                        colors[0]))
+                # ! Attention
+                drawed_objects[func_name + "_3d--" +
+                               convert_color_to_hex(colors[0])] = result
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" + color] = item
+            elif func.__name__ == "add_collection3d":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "_3d--" + convert_color_to_hex(color))
+                drawed_objects[func_name + "_3d--" +
+                               convert_color_to_hex(color)] = result
+
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "_makeline":
+                color = convert_color_to_hex(result[1]["color"])
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result[0]
+            elif func.__name__ == "axhline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "axvline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "_fill_between_x_or_y":
+                color = convert_color_to_hex(list(result.get_facecolors()[0]))
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(
+                        list(item._original_facecolor))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "scatter" and not isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                        drawed_objects[func_name + "--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "--" + kwargs["cmap"].name)  # ! Attention
+                        drawed_objects[func_name + "--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    if len(result.get_facecolor()) != 0:
+                        color = convert_color_to_hex(
+                            list(result.get_facecolor()[0]))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "pie":
+                for item in result[0]:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "axvspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "axhspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "hlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result   # ! Attention
+            elif func.__name__ == "vlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result   # ! Attention
+            elif func.__name__ == "boxplot":
+                for item in result["boxes"]:
+                    if isinstance(item, matplotlib.patches.PathPatch):
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" +
+                                       color] = item  # ! Attention
+            elif func.__name__ == "violinplot":
+                for item in result["bodies"]:
+                    color = convert_color_to_hex(list(item.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" +
+                                   color] = item  # ! Attention
+            elif func.__name__ == "hist":
+                tops, bins, patches = result
+                if not isinstance(patches, matplotlib.cbook.silent_list):
+                    for item in patches:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" + color] = item
+                else:
+                    for container in patches:
+                        for item in container:
+                            color = convert_color_to_hex(
+                                list(item.get_facecolor()))
+                            drawed_colors.append(func_name + "--" + color)
+                            drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "quiver":
+                for item in result.get_facecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result  # ! Attention
+            elif func.__name__ == "plot" and len(args) > 0 and isinstance(args[0], PolarAxes):
+                lines = result
+                for line in lines:
+                    color = convert_color_to_hex(line.get_color())
+                    # print("color", color)
+                    drawed_colors.append(func_name + "_polar" + "--" + color)
+                    drawed_objects[func_name + "_polar" + "--" + color] = line
+            elif func.__name__ == "scatter" and isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + kwargs["cmap"])
+                        drawed_objects[func_name +
+                                       "_polar--" + kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + kwargs["cmap"].name)
+                        drawed_objects[func_name + "_polar" +
+                                       "--" + kwargs["cmap"].name] = result
+                else:
+                    if len(result.get_facecolor()) != 0:
+                        color = convert_color_to_hex(
+                            list(result.get_facecolor()[0]))
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + color)
+                        drawed_objects[func_name + "_polar" +
+                                       "--" + color] = result  # ! Attention
+            elif func.__name__ == "plot" and "squarify" in func_name:
+                # get ax
+                ax = result
+                # get container
+                containers = ax.containers
+                for container in containers:
+                    for item in container:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(
+                            func_name + "_squarify" + "--" + color)
+                        drawed_objects[func_name +
+                                       "_squarify" + "--" + color] = item
+            elif func.__name__ == "imshow":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "pcolor":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "contour":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "contourf":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "fill":
+                patches = result
+                for patch in patches:
+                    color = convert_color_to_hex(list(patch.get_facecolor()))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = patch
+            elif func.__name__ == "__init__" and isinstance(args[0], NonUniformImage):
+                colormap = args[0].get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" + colormap] = args[0]
+            elif func.__name__ == "broken_barh":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "--" + convert_color_to_hex(color))
+                drawed_objects[func_name + "--" +
+                               convert_color_to_hex(color)] = result
+            elif func.__name__ == "__init__" and isinstance(args[0], Ellipse):
+                color = convert_color_to_hex(args[0].get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            elif func.__name__ == "tripcolor":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "__init__" and isinstance(args[0], VennDiagram):
+                for item in args[0].patches:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            elif func.__name__ == "__init__" and isinstance(args[0], Circle):
+                color = convert_color_to_hex(args[0].get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def update_drawed_colors(drawed_obejcts):
+    drawed_colors = []
+    for name, obj in drawed_objects.items():
+        func_name = name.split("--")[0]
+        color = name.split("--")[1]
+
+        if "/_makeline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axhline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axvline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/_fill_between_x_or_y" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolors()[0]))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/bar" in func_name and "_3d" not in func_name:
+            color = convert_color_to_hex(list(obj._original_facecolor))
+            if color is not None:
+                drawed_colors.append(func_name + "--" + color)
+        elif "/scatter" in func_name and "polar" not in func_name and "3d" not in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "--" + color)
+            else:
+                if len(obj.get_facecolor()) != 0:
+                    color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+        elif "/pie" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axvspan" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axhspan" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/hlines" in func_name:
+            for item in obj.get_edgecolors():
+                color = convert_color_to_hex(list(item))
+                drawed_colors.append(func_name + "--" + color)
+        elif "/vlines" in func_name:
+            for item in obj.get_edgecolors():
+                color = convert_color_to_hex(list(item))
+                drawed_colors.append(func_name + "--" + color)
+        elif "/boxplot" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/violinplot" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/hist" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/quiver" in func_name:
+            for item in obj.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+        elif "/plot" in func_name and "polar" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "_polar--" + color)
+        elif "/scatter" in func_name and "polar" in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_polar--" + color)
+            else:
+                if len(obj.get_facecolor()) != 0:
+                    color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "_polar--" + color)
+        elif "/plot" in func_name and "_squarify" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/imshow" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/pcolor" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/contour" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/contourf" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/fill" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/__init__" in func_name and isinstance(obj, NonUniformImage):
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/broken_barh" in func_name:
+            colors = obj.get_facecolors().tolist()
+            for color in colors:
+                drawed_colors.append(
+                    func_name + "--" + convert_color_to_hex(color))
+        elif "/__init__" in func_name and isinstance(obj, Ellipse):
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/tripcolor" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/__init__" in func_name and isinstance(obj, VennDiagram):
+            for item in obj.patches:
+                color = convert_color_to_hex(item.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+        elif "/__init__" in func_name and isinstance(obj, Circle):
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/scatter" in func_name and "3d" in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_3d--" + color)
+            else:
+                for item in obj.get_facecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "_3d--" + color)
+        elif "/plot" in func_name and "3d" in func_name and "plot_surface" not in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "_3d--" + color)
+        elif "/plot_surface" in func_name:
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_3d--" + color)
+            else:
+                colors = obj.get_facecolors().tolist()
+                drawed_colors.append(
+                    func_name +
+                    "_3d--" +
+                    convert_color_to_hex(
+                        colors[0]))
+        elif "/bar3d" in func_name:
+            colors = obj.get_facecolors().tolist()
+            drawed_colors.append(
+                func_name +
+                "_3d--" +
+                convert_color_to_hex(
+                    colors[0]))
+        elif "/bar" in func_name and "3d" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "_3d--" + color)
+        elif "/add_collection3d" in func_name:
+            colors = obj.get_facecolors().tolist()
+            for color in colors:
+                drawed_colors.append(
+                    func_name + "_3d--" + convert_color_to_hex(color))
+        elif "/draw_networkx_labels" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/draw_networkx_edges" in func_name:
+            if isinstance(obj, list):
+                for line in obj:
+                    color = convert_color_to_hex(line.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+            else:
+                for item in obj.get_edgecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+        elif "/draw_networkx_nodes" in func_name:
+            for item in obj.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+
+    drawed_colors = list(set(drawed_colors))
+
+    return drawed_colors
+
+
+_process_plot_var_args._makeline = log_function(
+    _process_plot_var_args._makeline)
+Axes.bar = log_function(Axes.bar)
+Axes.scatter = log_function(Axes.scatter)
+Axes.axhline = log_function(Axes.axhline)
+Axes.axvline = log_function(Axes.axvline)
+Axes._fill_between_x_or_y = log_function(Axes._fill_between_x_or_y)
+Axes.pie = log_function(Axes.pie)
+Axes.axvspan = log_function(Axes.axvspan)
+Axes.axhspan = log_function(Axes.axhspan)
+Axes.hlines = log_function(Axes.hlines)
+Axes.vlines = log_function(Axes.vlines)
+Axes.boxplot = log_function(Axes.boxplot)
+Axes.violinplot = log_function(Axes.violinplot)
+Axes.hist = log_function(Axes.hist)
+# Axes.plot = log_function(Axes.plot)
+PolarAxes.plot = log_function(PolarAxes.plot)
+Axes.quiver = log_function(Axes.quiver)
+Axes.imshow = log_function(Axes.imshow)
+Axes.pcolor = log_function(Axes.pcolor)
+Axes.contour = log_function(Axes.contour)
+Axes.contourf = log_function(Axes.contourf)
+Axes.fill = log_function(Axes.fill)
+NonUniformImage.__init__ = log_function(NonUniformImage.__init__)
+Ellipse.__init__ = log_function(Ellipse.__init__)
+Axes.broken_barh = log_function(Axes.broken_barh)
+
+nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx_pylab.draw_networkx_nodes)
+nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx_pylab.draw_networkx_edges)
+nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx_pylab.draw_networkx_labels)
+
+nx.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx.draw_networkx_nodes)
+nx.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx.draw_networkx_edges)
+nx.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx.draw_networkx_labels)
+
+
+squarify.plot = log_function(squarify.plot)
+
+Axes3D.scatter = log_function_for_3d(Axes3D.scatter)
+Axes3D.plot = log_function_for_3d(Axes3D.plot)
+Axes3D.plot_surface = log_function_for_3d(Axes3D.plot_surface)
+Axes3D.bar3d = log_function_for_3d(Axes3D.bar3d)
+Axes3D.bar = log_function_for_3d(Axes3D.bar)
+Axes3D.add_collection3d = log_function_for_3d(Axes3D.add_collection3d)
+
+Axes.tripcolor = log_function(Axes.tripcolor)
+
+VennDiagram.__init__ = log_function(VennDiagram.__init__)
+
+Circle.__init__ = log_function(Circle.__init__)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_utils.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+# This is a patch for color map, which is not updated for newer version of
+# numpy
+
+
+def patch_asscalar(a):
+    return a.item()
+
+
+setattr(np, "asscalar", patch_asscalar)
+
+
+def hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip('#')
+    return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+
+def rgb_to_lab(rgb):
+    """
+    Convert an RGB color to Lab color space.
+    RGB values should be in the range [0, 255].
+    """
+    # Create an sRGBColor object from RGB values
+    from colormath.color_objects import sRGBColor, LabColor
+    from colormath.color_conversions import convert_color
+    rgb_color = sRGBColor(rgb[0], rgb[1], rgb[2], is_upscaled=True)
+
+    # Convert to Lab color space
+    lab_color = convert_color(rgb_color, LabColor)
+
+    return lab_color
+
+
+def calculate_similarity_single(c1, c2):
+    if c1.startswith("#") and c2.startswith("#"):
+        # c1 = rgb2lab(np.array([hex_to_rgb(c1)]))
+        # c2 = rgb2lab(np.array([hex_to_rgb(c2)]))
+        c1 = hex_to_rgb(c1)
+        c2 = hex_to_rgb(c2)
+        lab1 = rgb_to_lab(c1)
+        lab2 = rgb_to_lab(c2)
+        # return max(0, 1 - deltaE_cie76(c1, c2)[0] / 100)
+        from colormath.color_diff import delta_e_cie2000
+        return max(0, 1 - (delta_e_cie2000(lab1, lab2) / 100))
+    elif not c1.startswith("#") and not c2.startswith("#"):
+
+        return 1 if c1 == c2 else 0
+    else:
+        return 0
+
+
+def filter_color(color_list):
+    filtered_color_list = []
+    len_color_list = len(color_list)
+    for i in range(len_color_list):
+        if i != 0:
+            put_in = True
+            for item in filtered_color_list:
+                similarity = calculate_similarity_single(
+                    color_list[i].split("--")[1], item.split("--")[1])
+                if similarity > 0.7:
+                    put_in = False
+                    break
+            if put_in:
+                filtered_color_list.append(color_list[i])
+        else:
+            filtered_color_list.append(color_list[i])
+    # print("Filtered color list: ", filtered_color_list)
+    return filtered_color_list
+
+
+def group_color(color_list):
+    color_dict = {}
+
+    for color in color_list:
+        chart_type = color.split("--")[0]
+        color = color.split("--")[1]
+
+        if chart_type not in color_dict:
+            color_dict[chart_type] = [color]
+        else:
+            color_dict[chart_type].append(color)
+
+    return color_dict

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/grid_evaluator.py

@@ -0,0 +1,181 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class GridEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_grids = self._log_legends(generation_code_file)
+        golden_grids = self._log_legends(golden_code_file)
+
+        self._calculate_metrics(generation_grids, golden_grids)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_legends(self, code_file):
+        """
+        Get legend objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", ".txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_legends.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        with open(output_file, 'r') as f:
+            texts = f.read()
+            texts = eval(texts)
+
+        os.remove(code_log_texts_file)
+        os.remove(output_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_grids: List[Tuple],
+            golden_grids: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_grids: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_grids: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_grids) == 0 or len(golden_grids) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_grids)
+        len_golden = len(golden_grids)
+
+        n_correct = 0
+        for t in golden_grids:
+            if t in generation_grids:
+                n_correct += 1
+                generation_grids.remove(t)
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+grid_visibility = []
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+all_axes = plt.gcf().get_axes()
+
+for ax in all_axes:
+    subplot_spec = ax.get_subplotspec()
+    row = subplot_spec.rowspan.start
+    col = subplot_spec.colspan.start
+    x_grid_visible = any(line.get_visible() for line in ax.get_xgridlines())
+    y_grid_visible = any(line.get_visible() for line in ax.get_ygridlines())
+
+    grid_visibility.append(
+        dict(
+            row=row,
+            col=col,
+            x_grid_visible=x_grid_visible,
+            y_grid_visible=y_grid_visible
+        )
+    )
+
+# sort the grid visibility by row and col
+grid_visibility = sorted(grid_visibility, key=lambda x: (x['row'], x['col']))
+
+# Since there can be twin axes, we need to merge the grid visibility, if they are in the same row and col, use "or" to merge
+grid_visibility_merged = []
+for i, grid in enumerate(grid_visibility):
+    if i == 0:
+        grid_visibility_merged.append(grid)
+        continue
+
+    last_grid = grid_visibility_merged[-1]
+    if last_grid['row'] == grid['row'] and last_grid['col'] == grid['col']:
+        last_grid['x_grid_visible'] = last_grid['x_grid_visible'] or grid['x_grid_visible']
+        last_grid['y_grid_visible'] = last_grid['y_grid_visible'] or grid['y_grid_visible']
+    else:
+        grid_visibility_merged.append(grid)
+
+grid_visibility = grid_visibility_merged
+
+# print(grid_visibility)
+with open('{output_file}', 'w') as f:
+    f.write(str(grid_visibility))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = GridEvaluator()
+
+    for idx in range(1, 40):
+        print(f"Processing {idx}")
+        generation_code_file = f"/home/yc21/project/Princess-s-CHI/dataset/line/line_{idx}.py"
+        golden_code_file = f"/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_{idx}.py"
+        evaluator(generation_code_file, golden_code_file)
+        print()

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/layout_evaluator.py

@@ -0,0 +1,166 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+class LayoutEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_layouts = self._log_layouts(generation_code_file)
+        golden_layouts = self._log_layouts(golden_code_file)
+
+        self._calculate_metrics(generation_layouts, golden_layouts)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+
+        # print(self.metrics)
+
+    def _log_layouts(self, code_file):
+        """
+        Get objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_layouts.txt")
+        if "/graph" in code_file:
+            suffix = self._get_suffix_special_for_graph(output_file)
+        else:
+            suffix = self._get_suffix(output_file)
+
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_layouts.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, 'r') as f:
+                texts = f.read()
+                texts = eval(texts)
+            os.remove(output_file)
+        else:
+            texts = []
+        os.remove(code_log_texts_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_layouts: List[Tuple],
+            golden_layouts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_layouts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_layouts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_layouts) == 0 or len(golden_layouts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_layouts)
+        len_golden = len(golden_layouts)
+
+        n_correct = 0
+        for t in golden_layouts:
+            if t in generation_layouts:
+                n_correct += 1
+                generation_layouts.remove(t)
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        return """
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+def get_gridspec_layout_info(fig):
+    layout_info = {{}}
+    for ax in fig.axes:
+        spec = ax.get_subplotspec()
+        if spec is None:
+            continue
+        gs = spec.get_gridspec()
+        nrows, ncols = gs.get_geometry()
+        row_start, row_end = spec.rowspan.start, spec.rowspan.stop - 1  # Zero-based and inclusive
+        col_start, col_end = spec.colspan.start, spec.colspan.stop - 1  # Zero-based and inclusive
+        layout_info[ax] = dict(nrows=nrows, ncols=ncols, row_start=row_start, row_end=row_end, col_start=col_start, col_end=col_end)
+    # print(layout_info)
+    layout_info = list(layout_info.values())
+    return layout_info
+
+layout_info = get_gridspec_layout_info(fig=plt.gcf())
+with open('{output_file}', 'w') as f:
+    f.write(str(layout_info))
+"""
+
+    def _get_suffix_special_for_graph(self, output_file):
+        return f"""
+def get_gridspec_layout_info(fig):
+    layout_info = {{}}
+    for ax in fig.axes:
+        layout_info[ax] = dict(nrows=1, ncols=1, row_start=0, row_end=1, col_start=0, col_end=1)
+    # print(layout_info)
+    layout_info = list(layout_info.values())
+    return layout_info
+
+layout_info = get_gridspec_layout_info(fig=plt.gcf())
+with open('{output_file}', 'w') as f:
+    f.write(str(layout_info))
+"""
+
+
+if __name__ == "__main__":
+
+    evaluator = LayoutEvaluator()
+
+    for idx in range(60, 61):
+        print(f"Processing {idx}")
+        # print("Processing Golden Code")
+        golden_code_file = f"{os.environ['PROJECT_PATH']}/dataset/ori/line_{idx}.py"
+        # print("Processing Generation Code")
+        generation_code_file = f"{os.environ['PROJECT_PATH']}/results/chart2code_gpt_ScaffoldAgent_results/scaffold/line_{idx}.py"
+        evaluator(generation_code_file, golden_code_file)
+        print()

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/legend_evaluator.py

@@ -0,0 +1,194 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class LegendEvaluator:
+
+    def __init__(self, use_position=True) -> None:
+        self.use_position = use_position
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_texts = self._log_legends(generation_code_file)
+        golden_texts = self._log_legends(golden_code_file)
+
+        self._calculate_metrics(generation_texts, golden_texts)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_legends(self, code_file):
+        """
+        Get legend objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", ".txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_legends.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        with open(output_file, 'r') as f:
+            texts = f.read()
+            texts = eval(texts)
+
+        os.remove(code_log_texts_file)
+        os.remove(output_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_texts: List[Tuple],
+            golden_texts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_texts) == 0 or len(golden_texts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_texts)
+        len_golden = len(golden_texts)
+
+        if not self.use_position:
+            generation_texts = [t[-1] for t in generation_texts]
+            golden_texts = [t[-1] for t in golden_texts]
+
+            n_correct = 0
+            for t in golden_texts:
+                if t in generation_texts:
+                    n_correct += 1
+                    generation_texts.remove(t)
+
+        else:
+            generation_texts = [t[2:] for t in generation_texts]
+            golden_texts = [t[2:] for t in golden_texts]
+
+            n_correct = 0
+            for t1 in golden_texts:
+                for t2 in generation_texts:
+                    # text must be equal, but x_rel and y_rel can be in a range
+                    if t1[-1] == t2[-1] and abs(t1[0] - t2[0]
+                                                ) <= 10 and abs(t1[1] - t2[1]) <= 10:
+                        # print("matched:", t2)
+                        n_correct += 1
+                        generation_texts.remove(t2)
+                        break
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+drawed_legend_texts = []
+drawed_texts = []
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_texts
+
+        object = args[0]
+        x = args[2]
+        y = args[3]
+        x_rel = ( x / object.width / 72 ) * 100
+        y_rel = ( y / object.height / 72 ) * 100
+        s = args[4]
+
+        drawed_texts.append( (x, y, x_rel, y_rel, s) )
+        return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+RendererPdf.draw_text = log_function(RendererPdf.draw_text)
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+all_axes = plt.gcf().get_axes()
+legends = [ax.get_legend() for ax in all_axes if ax.get_legend() is not None]
+for legend in legends:
+    for t in legend.get_texts():
+        drawed_legend_texts.append(t.get_text())
+
+new_drawed_legend_texts = []
+for t1 in drawed_legend_texts:
+    for t2 in drawed_texts:
+        if t1 == t2[-1]:
+            new_drawed_legend_texts.append(t2)
+            break
+drawed_legend_texts = new_drawed_legend_texts
+
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_legend_texts))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = LegendEvaluator()
+
+    generation_code_file = "/home/yc21/project/Princess-s-CHI/dataset/line/line_9.py"
+    golden_code_file = "/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_9.py"
+
+    evaluator(generation_code_file, golden_code_file)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/text_evaluator.py

@@ -0,0 +1,202 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class TextEvaluator:
+
+    def __init__(self, use_position=False, use_axs=True) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+        self.use_position = use_position
+        self.use_axs = use_axs
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_texts = self._log_texts(generation_code_file)
+        golden_texts = self._log_texts(golden_code_file)
+
+        self._calculate_metrics(generation_texts, golden_texts)
+
+        # [TAG] What is this for?
+        # print(f"os.getcwd(): {os.getcwd()}")
+        # breakpoint()
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_texts(self, code_file):
+        """
+        Get text objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_texts.txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        if not self.use_axs:
+            # find plt.savefig and append code before it
+            savefig_idx = code.find("plt.savefig")
+            ax_ticks_deletion_code = self._get_ax_ticks_deletion_code()
+            code = code[:savefig_idx] + \
+                ax_ticks_deletion_code + code[savefig_idx:]
+
+        code_log_texts_file = code_file.replace(".py", "_log_texts.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, 'r') as f:
+                texts = f.read()
+                texts = eval(texts)
+            os.remove(output_file)
+        else:
+            texts = []
+        os.remove(code_log_texts_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_texts: List[Tuple],
+            golden_texts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_texts) == 0 or len(golden_texts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_texts)
+        len_golden = len(golden_texts)
+
+        if not self.use_position:
+            generation_texts = [t[-1] for t in generation_texts]
+            golden_texts = [t[-1] for t in golden_texts]
+
+            n_correct = 0
+            for t in golden_texts:
+                if t in generation_texts:
+                    n_correct += 1
+                    generation_texts.remove(t)
+
+        else:
+            generation_texts = [t[2:] for t in generation_texts]
+            golden_texts = [t[2:] for t in golden_texts]
+
+            n_correct = 0
+            for t1 in golden_texts:
+                for t2 in generation_texts:
+                    # text must be equal, but x_rel and y_rel can be in a range
+                    if t1[-1] == t2[-1] and abs(t1[0] - t2[0]
+                                                ) <= 10 and abs(t1[1] - t2[1]) <= 10:
+                        # print("matched:", t2)
+                        n_correct += 1
+                        generation_texts.remove(t2)
+                        break
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+import sys
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+drawed_texts = []
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_texts
+
+        object = args[0]
+        x = args[2]
+        y = args[3]
+        x_rel = ( x / object.width / 72 ) * 100
+        y_rel = ( y / object.height / 72 ) * 100
+        s = args[4]
+
+        drawed_texts.append( (x, y, x_rel, y_rel, s) )
+        return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+RendererPdf.draw_text = log_function(RendererPdf.draw_text)
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+# print("drawed_texts", drawed_texts)
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_texts))
+"""
+
+    def _get_ax_ticks_deletion_code(self):
+        return """
+all_axes = plt.gcf().get_axes()
+for ax in all_axes:
+    ax.set_xticks([])
+    ax.set_yticks([])
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = TextEvaluator(use_axs=False)
+    # evaluator = TextEvaluator()
+
+    generation_code_file = "/home/yc21/project/Princess-s-CHI/dataset/line/line_7.py"
+    golden_code_file = "/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_7.py"
+
+    evaluator(generation_code_file, golden_code_file)

VLMEvalKit-sudoku/vlmeval/dataset/utils/crpe.py

@@ -0,0 +1,13 @@
+import json
+import argparse
+from collections import defaultdict
+
+
+def is_correct(predict, answer):
+    # predict是标准答案 answer是预测
+    if len(answer) == 1:
+        return answer[0] == predict[0]
+    elif len(answer) != 1 and answer[0] in ['A', 'B', 'C', 'D']:
+        return answer[0] == predict[0]
+    elif len(answer) != 1 and answer[0] not in ['A', 'B', 'C', 'D']:
+        return predict[4:].lower() in answer.lower()

VLMEvalKit-sudoku/vlmeval/dataset/utils/mathverse.py

@@ -0,0 +1,193 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_extract_ICE():
+    example_1 = """
+1.
+Model response: 'Rounded to two decimal places, the perimeter of the sector is approximately:\n\n(-2, 1)'
+Extracted Answer: (-2, 1)
+""" # noqa
+
+    example_2 = """
+2.
+Model response: 'at those points.\n\nTherefore, the correct option that represents the meaning of the intersection points of the graphs is:\n\nD. They give the solutions to the equation $f(t)=g(t)$.",'
+Extracted Answer: D
+""" # noqa
+
+    example_3 = """
+3.
+Model response: ' at 1 (there's a closed circle at y = 1), the range in interval notation is \\((-4, 1]\\).\n\nFinal values:\nDomain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)'
+Extracted Answer: Domain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)
+""" # noqa
+
+    example_4 = """
+4.
+Model response: 'As it stands, I cannot provide the correct option letter because there isn't enough information to solve for 'y'.'
+Extracted Answer: null
+""" # noqa
+
+    example_5 = """
+5.
+Model response: 'Given that AB = 17.6 meters, we can now substitute into the equation:\n\nd = 17.6 / cos(38\u00b0)\n\nTherefore, to one decimal place, the distance d between Ned and Bart is approximately 22.3 meters.'
+Extracted answer: 22.3
+""" # noqa
+
+    example_6 = """
+6.
+Model response:  have all the coefficients for the quadratic function:\n\\( f(x) = ax^2 + bx + c \\)\n\\( f(x) = -1x^2 - 2x + 1 \\)\n\nTherefore, the equation for the graphed function \\( f \\) is:\n\\( f(x) = -x^2 - 2x + 1 \\)"'
+Extracted answer: f(x) = -x^2 - 2x + 1
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4, example_5, example_6]
+
+
+def get_gpt4_score_ICE():
+    example_1 = """
+[Question]: Write the set of numbers represented on the number line in interval notation.
+[Standard Answer]: (-2,1]
+[Model_answer] : Extracted Answer: \\((-2, 1)\\)
+Judgement: 0
+""" # noqa
+
+    example_2 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : B:2\u221a{{3}}
+Judgement: 0
+""" # noqa
+
+    example_3 = """
+[Question]: Find the domain and range of the function f using interval notation.
+[Standard Answer]: domain: [-4, 0) and range: (-3, 1]
+[Model_answer] : Range: \\((-4, 1]\\)
+Judgement: 0
+""" # noqa
+
+    example_4 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : null
+Judgement: 0
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4]
+
+
+def build_mathverse_gpt4_extract_prompt(line):
+    task_description = """
+I am providing you a response from a model to a math problem, termed 'Model Response'. You should extract the answer from the response as 'Extracted Answer'. Directly output the extracted answer with no explanation.\n\n
+""" # noqa
+    prediction = str(line['prediction'])
+    demo_prompt = task_description
+    examples = get_gpt4_extract_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"Model response: '{prediction}'\nExtracted Answer: "
+    full_prompt = f'{demo_prompt}7.\n{test_prompt}'
+
+    return full_prompt
+
+
+def build_mathverse_gpt4_score_prompt(line):
+    task_description = """
+Below are two answers to a math question. Question is [Question], [Standard Answer] is the standard answer to the question, and [Model_answer] is the answer extracted from a model's output to this question.  Determine whether these two answers are consistent.
+Please note that only when the [Model_answer] completely matches the [Standard Answer] means they are consistent. For non-multiple-choice questions, if the meaning is expressed in the same way, it is also considered consistent, for example, 0.5m and 50cm.
+If they are consistent, Judement is 1; if they are different, Judement is 0.\n\n
+""" # noqa
+    question_for_eval = line['question_for_eval']
+    extract = line['extract']
+    answer = line['answer']
+    demo_prompt = task_description
+    examples = get_gpt4_score_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"""
+    [Question]: {question_for_eval}
+    [Standard Answer]: {answer}
+    [Model_answer] : {extract}
+    Judgement:"""
+    full_prompt = f'{demo_prompt}{test_prompt}'
+
+    return full_prompt
+
+
+def post_check_score(line, prefetch=False):
+    ans = str(line['answer']).strip()
+    response = str(line['extract']).strip()
+
+    if response == ans:
+        return response if prefetch else True
+    else:
+        return False
+
+
+def MathVerse_auxeval_extract(model, line):
+    prompt = build_mathverse_gpt4_extract_prompt(line)
+    log = ''
+    retry = 5
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_extract=log, extract=res)
+    log += 'All 5 retries failed.\n'
+    return dict(log_extract=log, extract='')
+
+
+def MathVerse_auxeval_score(model, line):
+    prompt = build_mathverse_gpt4_score_prompt(line)
+    log = ''
+    retry = 5
+    if post_check_score(line, prefetch=True):
+        res = post_check_score(line, prefetch=True)
+        return dict(log_score='Prefetch succeed', score=True)
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res or res.strip() not in ['0', '1']:
+            log += f'Try {i}: output is {prediction}, res is {res}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_score=log, score=int(res) == 1)
+    log += 'All 5 retries failed.\n'
+    return dict(log_score=log, score=False)
+
+
+def MathVerse_acc(result_file):
+    df = load(result_file)
+
+    df['metadata'] = df['metadata'].apply(lambda x: x.replace("'", '"'))
+    df['metadata'] = df['metadata'].apply(json.loads)
+    df_metadata = pd.json_normalize(df['metadata'])
+    df = pd.concat([df.drop('metadata', axis=1), df_metadata], axis=1)
+
+    subset = list(set(df['problem_version']))
+
+    res = defaultdict(list)
+    for p in subset:
+        if p != 'Overall':
+            sub = df[df['problem_version'] == p]
+        else:
+            sub = cp.deepcopy(df)
+        res['split'].append(p)
+        # Overall Acc
+        res['Overall'].append(np.mean(sub['score']) * 100)
+        # Subject
+        subjects = set(df['subject'])
+        for k in subjects:
+            res[k].append(np.mean(sub[sub['subject'] == k]['score']) * 100)
+        # Subfield
+        subfields = set(df['subfield'])
+        for k in subfields:
+            res[k].append(np.mean(sub[sub['subfield'] == k]['score']) * 100)
+
+    return pd.DataFrame(res)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/parsers.py

@@ -0,0 +1,145 @@
+import ast
+import json
+import re
+import regex  # Supports the non-standard ?R regex operator
+from typing import List
+from .utils import extract_code_block_content, extract_answer_at_beginning_of_line
+
+
+PARSING_TIMEOUT = 0.1
+
+
+def parse_json(response: str):
+    """Parse the JSON object, including nested JSON strings."""
+
+    response_ = extract_answer_at_beginning_of_line(response)
+
+    # If it's wrapped in code block like json, drop it
+    response_, _ = extract_code_block_content(response_, "json")
+
+    # Regular expression to match JSON-like structures, including nested quotes
+    json_pattern = r"(\{(?:[^{}]|(?R))*\}|\[(?:[^{}]|(?R))*\])"
+    string_pattern = r'"(?:\\.|[^"\\])*"'
+
+    # Find all potential JSON objects
+    try:
+        potential_jsons = regex.findall(
+            json_pattern, response_, timeout=PARSING_TIMEOUT
+        )
+    except TimeoutError:
+        if response_.startswith("["):
+            return []
+        return {}
+
+    valid_jsons = []
+
+    for potential_json in potential_jsons:
+        # Replace escaped quotes with a placeholder
+        potential_json = potential_json.replace('\\"', "__DOUBLE_QUOTE__")
+        potential_json = potential_json.replace("\\'", "__SINGLE_QUOTE__")
+
+        # Find all string literals
+        strings = regex.findall(string_pattern, potential_json)
+
+        # Process each string literal
+        for s in strings:
+            # Unescape the string content
+            unescaped = (
+                s[1:-1]
+                .replace("__DOUBLE_QUOTE__", '"')
+                .replace("__SINGLE_QUOTE__", "'")
+            )
+            # Try to parse it as JSON
+            try:
+                parsed = json.loads(unescaped)
+                if isinstance(parsed, (dict, list)):
+                    # If it's a valid JSON object or array, replace it in the original string
+                    potential_json = potential_json.replace(s, json.dumps(parsed))
+            except json.JSONDecodeError:
+                pass
+
+        # Restore escaped quotes
+        potential_json = potential_json.replace("__DOUBLE_QUOTE__", '\\"')
+        potential_json = potential_json.replace("__SINGLE_QUOTE__", "\\'")
+
+        try:
+            # Attempt to parse the potential JSON
+            json_object = json.loads(potential_json)
+            valid_jsons.append(json_object)
+        except json.JSONDecodeError:
+            # try to update single quote to double quote for some special failure case
+            # caused by quote's type
+            potential_json_ = re.sub(r"(?<!\w)\'|\'(?!\w)", '"', potential_json)
+            try:
+                json_object = json.loads(potential_json_)
+                valid_jsons.append(json_object)
+            except json.JSONDecodeError:
+                # If parsing still fails, it's not a valid JSON object
+                pass
+
+        try:
+            # Attempt to parse the Python structure
+            valid_jsons.append(ast.literal_eval(potential_json))
+            continue
+        except (SyntaxError, ValueError):
+            pass
+        # Escape the backslashes.
+        potential_json = potential_json.replace('\\"', '\\\\"')
+        potential_json = potential_json.replace("\\'", "\\\\'")
+        try:
+            # Attempt to parse the Python structure
+            valid_jsons.append(ast.literal_eval(potential_json))
+        except (SyntaxError, ValueError):
+            pass
+
+    # Return the last valid JSON if any, otherwise an empty dict or list
+    if valid_jsons:
+        return valid_jsons[-1]
+    if response_.startswith("["):
+        return []
+    return {}
+
+
+def parse_nested_str_list(input_string):
+    # Add quotation marks around the words in the string
+    quoted_string = re.sub(r"(\w+)", r'"\1"', input_string)
+
+    # Safely evaluate the string as a Python object
+    try:
+        python_object = ast.literal_eval(quoted_string)
+        return python_object
+    except (ValueError, SyntaxError) as e:
+        print(f"Failed to convert string to Python object: {e}")
+        return input_string
+
+
+def parse_syllable_ranges(input_str: str) -> List[List[int]]:
+    """Convert a bunch of syllable ranges into a list of intervals.
+
+    Examples:
+        parse_syllable_ranges('[7,10][7, 10][5,7][5,7][7,10]')
+        >>> [[7, 10], [7, 10], [5, 7], [5, 7], [7, 10]]
+        parse_syllable_ranges('575 575')
+        >>> [[5, 5], [7, 7], [5, 5], [0, 0], [5, 5], [7, 7], [5, 5]]
+        parse_syllable_ranges('[11]5')
+        >>> [[11, 11], [5, 5]]
+    """
+
+    def convert_to_range(match):
+        match = match.strip("[]")
+        if "," in match:
+            start, end = map(int, match.split(","))
+            return [start, end]
+        elif match == " ":
+            return [0, 0]
+        else:
+            num = int(match)
+            return [num, num]
+
+    # Split the input string into chunks
+    chunks = re.findall(r"(?:\[\d+(?:,\s*\d+)?\]|\d| )", input_str.strip())
+
+    # Convert each chunk to a range and create the result list
+    result = [convert_to_range(chunk) for chunk in chunks]
+
+    return result

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/utils.py

@@ -0,0 +1,138 @@
+import re
+import ast
+
+
+def extract_code_block_content(
+    response,
+    code_type=None,
+    is_ascii_art: bool = False,
+    should_remove_surrounding_whitespace=True,
+):
+    # If code_type is specified, construct the pattern to match that specific code block
+    if code_type:
+        pattern = rf"```{code_type}\s*\n*(.*?)\s*```"
+    elif is_ascii_art:
+        if not response.strip() or len(response) > 10000:
+            # handle the special case of pure whitespace or super long empty string
+            response = response.rstrip()
+        if should_remove_surrounding_whitespace:
+            pattern = r"```\w*(?:\s*\n+)?(.*?)\s*```"
+        else:
+            pattern = r"```\w*(?:\s*\n+)?(.*?)(?:\n+\s*)?```"
+    else:
+        # If code_type is None, match any code block
+        pattern = r"```\w*\s*\n*(.*?)\s*```"
+
+    # Search for the code block in the response
+    match = re.search(pattern, response, flags=re.DOTALL)
+
+    if match:
+        # If a match is found, return the content inside the code block
+        if is_ascii_art:
+            return match.group(1), True
+        else:
+            return match.group(1).strip(), True
+    else:
+        # If no code block is found, return the original string
+        return response, False
+
+
+def extract_answer_content(
+    response, is_ascii_art=False, should_remove_surrounding_whitespace=True
+):
+    if is_ascii_art:
+        match = re.search(r"\*\*?Answer:(.*?)\*\*?|\bAnswer:(.*)", response, re.DOTALL)
+    else:
+        match = re.search(
+            r"\*\*?Answer:\s*(.*?)\*\*?|\bAnswer:\s*(.*)", response, re.DOTALL
+        )
+    if match:
+        # Extract the content after "Answer:"
+        response = match.group(1) or match.group(
+            2
+        )  # Return the first capturing group or second if the first is None
+        if response is None:
+            response = ""
+    if is_ascii_art:
+        # Reduce anything that is more than one blank line to a single blank line.
+        response = re.sub(r"^\s*$(\n^\s*$)+", "", response, flags=re.MULTILINE)
+
+        if should_remove_surrounding_whitespace:
+            # Remove trailing whitespace
+            response = response.rstrip()
+        else:
+            # Remove trailing blank lines
+            response = re.sub(r"(\n\s*)+$", "", response)
+        # Remove leading blank lines
+        response = re.sub(r"^(\s*\n)+", "", response)
+    else:
+        response = response.strip()
+
+    return response
+
+
+def extract_answer_at_beginning_of_line(response):
+    # Regular expression to match either "Answer:" or "**Answer:**" at the beginning of a new line
+    match = re.search(r"^(?:\*\*Answer:|Answer:)\s*(.+)", response, re.MULTILINE)
+
+    if match:
+        # Return the content after "Answer:" or "**Answer: **"
+        return match.group(1).strip()
+    else:
+        # Return None if no match is found
+        return response.strip()
+
+
+def drop_additional_text(result):
+    # Heuristic to catch multiple-choice queries. Does not use metadata.json.
+    result_first_paragraph = result.split("\n\n")[0].strip()
+    potential_ans_in_single_line = re.search(
+        r"^(?:(?:[a-zA-Z0-9_-]+)(?:,\s*[a-zA-Z0-9_-]+)*|(?:[a-zA-Z0-9_-]+)\.|\((?:[a-zA-Z0-9_-]+)\)$)",
+        result_first_paragraph,
+    )
+
+    only_return_first_paragraph = (
+        potential_ans_in_single_line
+        and result_first_paragraph.strip() != ""
+        and not _is_multiline_answer(result)
+    )
+
+    if only_return_first_paragraph:
+        return result_first_paragraph
+    else:
+        return result
+
+
+def _is_multiline_answer(text):
+    # Split the text into lines
+    lines = text.splitlines()
+
+    # Find the "Answer:" line
+    for i, line in enumerate(lines):
+        stripped_line = line.strip()
+        if stripped_line != "":
+            # Check if the next line (second line after "Answer:") is blank
+            if i + 1 < len(lines) and lines[i + 1].strip() == "":
+                return False  # Second line is blank, single-line answer,
+                # remaining parts are additional
+            return True  # Second line is not blank, multi-line answer
+
+    return False  # empty result found, treat as single-line
+
+
+def evaluate_as_string(s):
+    try:
+        # Try to evaluate the string using ast.literal_eval
+        evaluated = ast.literal_eval(s)
+        # If it's a valid Python string, return it
+        if isinstance(evaluated, str):
+            return evaluated
+        else:
+            # If it's not a string, return the original input
+            return s
+    except (ValueError, SyntaxError):
+        # If it's not valid, return the original input
+        return s
+    except MemoryError:
+        # the result overflows, simply return an empty string
+        return ""

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py

@@ -0,0 +1,126 @@
+"""Return if two ASCII art images depict the same thing."""
+
+import logging
+from numbers import Number
+import os
+import requests
+from .common.conversions import ascii_text_to_image
+from .vlm_as_judge import OpenAIVLMJudger
+"""Return if two ASCII art images depict the same thing."""
+
+
+class AsciiArtGPT4OJudge(OpenAIVLMJudger):
+    """A GPT-4o judge for assessing if two ASCII art images depict the same thing."""
+
+    def __init__(self, metric_config, model="gpt-4o-2024-08-06"):
+        self.eval_prompt = """Determine if the following two ASCII art images depict the same object.
+        Your answer should be either "yes" or "no", but without the quotation marks."""
+        super().__init__(
+            metric_config,
+            model,
+        )
+
+    def encode_image(self, image):
+        """Encode an image into base64 and return its mime type."""
+        mime_type = "image/jpeg"
+        image_format = "JPEG"
+
+        if image.mode == "RGBA":
+            image = self._rgba_to_rgb(image)
+
+        if self.resize and max(image.size) > self.max_side:
+            image = self._resize_image(image)
+            encoded_image = self._encode_image(image, image_format)
+        else:
+            encoded_image = self._encode_image(image, image_format)
+
+        return encoded_image, mime_type
+
+    def create_image_content(self, image):
+        base64_image, mime_type = self.encode_image(image)
+        return {
+            "type": "image_url",
+            "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+        }
+
+    def prepare_eval_prompt(self, images):
+        """Prepare the evaluation prompt."""
+        content = []
+        for image_path in images:
+            content.append(self.create_image_content(image_path))
+
+        content.append({"type": "text", "text": self.eval_prompt})
+        return content
+
+    def query(self, images):
+        """Query GPT4o to determine if the ASCII images show the same thing."""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        context = self.prepare_eval_prompt(images)
+
+        query_payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": context}],
+            "temperature": 0.0,
+        }
+
+        response_data = None
+        while response_data is None:
+            try:
+                response = requests.post(
+                    self.url,
+                    headers=headers,
+                    json=query_payload,
+                )
+            except (requests.exceptions.JSONDecodeError, requests.exceptions.ConnectionError) as e:
+                print(f'Error in requests: {e}')
+                print('Retry...')
+                continue
+
+            response_ = response.json()
+            if "error" in response_:
+                error_info = response_["error"]
+                print(
+                    f"Got error with type: {error_info['type']}. Message: {error_info['message']}"
+                )
+                print("Retry...")
+            else:
+                response_data = response_
+                break
+
+        total_tokens = response_data.get("usage", {}).get("total_tokens", "N/A")
+
+        if response_data and "choices" in response_data:
+            choices = response_data["choices"]
+            if choices and "message" in choices[0]:
+                message_content = choices[0]["message"]["content"]
+                print(
+                    f"gpt-4o judge results: {message_content}; tokens:{total_tokens}"
+                )
+        else:
+            print("gpt-4o judge query failed...")
+            message_content = ""
+
+        return message_content
+
+
+class AsciiArtVLMJudgeScore:
+    """Compute the cosine similarity between two pieces of ASCII art."""
+
+    def __init__(self, metric_config):
+        self.model = AsciiArtGPT4OJudge(metric_config)
+
+    def match(self, response, correct_answer) -> Number:
+        """Compute the cosine similarity between two pieces of ASCII art."""
+        if not isinstance(response, str) or not isinstance(correct_answer, str):
+            return 0
+        if not response:
+            return 0
+        response_image = ascii_text_to_image(response, 224, 224)
+        correct_answer_image = ascii_text_to_image(correct_answer, 224, 224)
+
+        eval_results = self.model.query([response_image, correct_answer_image])
+        return 1 if "yes" in eval_results.lower() else 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/conversions.py

@@ -0,0 +1,244 @@
+import ast
+import json
+import re
+from matplotlib import font_manager
+from PIL import Image, ImageDraw, ImageFont
+from ...parsing.common.parsers import parse_json
+from numbers import Number
+from typing import Tuple, Union
+
+
+def freeze_structure(obj):
+    """Freeze a structure and make it hashable."""
+    if isinstance(obj, dict):
+        return frozenset((k, freeze_structure(v)) for k, v in obj.items())
+    elif isinstance(obj, (list, tuple)):
+        return tuple(freeze_structure(item) for item in obj)
+    elif isinstance(obj, set):
+        return frozenset(obj)
+    else:
+        return obj
+
+
+def cast_to_set(object) -> set:
+    """Try to cast an object as a set."""
+    object = freeze_structure(object)
+    if isinstance(object, (frozenset, set, tuple)):
+        return set(object)
+    return str_to_set(object)
+
+
+def cast_to_dict(object) -> dict:
+    """Try to cast an object as a dict."""
+    if isinstance(object, dict):
+        return {key: cast_to_dict(val) for key, val in object.items()}
+    elif isinstance(object, str):
+        extract_json_attempt = parse_json(object)
+        if extract_json_attempt:
+            return extract_json_attempt
+        return object
+    else:
+        return object
+
+
+def str_to_iterable(func, iterable_str):
+    """Converts a string representation of an iterable to an iterable."""
+    if not isinstance(iterable_str, str):
+        return func()
+
+    iterable_str = iterable_str.strip(" ")
+    if not iterable_str:
+        return func()
+
+    is_in_iterable = True
+    if iterable_str[0] == "(":
+        if not iterable_str.endswith(")"):
+            return func()
+    elif iterable_str[0] == "{":
+        if not iterable_str.endswith("}"):
+            return func()
+    elif iterable_str[0] == "[":
+        if not iterable_str.endswith("]"):
+            return func()
+    else:
+        is_in_iterable = False
+
+    # We may have a nested object, so try to use eval first
+    try:
+        eval_ = ast.literal_eval(iterable_str)
+        if eval_ is None:
+            return ""
+        if isinstance(eval_, (int, float)):
+            eval_ = [
+                eval_,
+            ]
+        return func(eval_)
+    except (SyntaxError, ValueError):
+        if is_in_iterable:
+            iterable_str = iterable_str[1:-1]
+        items = [item.strip() for item in iterable_str.split(",")]
+        return func(items)
+
+
+def str_to_set(iterable_str) -> set:
+    """Converts a string representation of an iterable to a set."""
+    return str_to_iterable(set, iterable_str)
+
+
+def str_to_list(iterable_str) -> set:
+    """Converts a string representation of an iterable to a set."""
+    return str_to_iterable(list, iterable_str)
+
+
+def str_to_bboxes(bbox_list) -> list:
+    if not isinstance(bbox_list, str):
+        return []
+    try:
+        bboxes = ast.literal_eval(bbox_list)
+    except (SyntaxError, ValueError):
+        try:
+            bboxes = json.loads(bbox_list)
+        except json.JSONDecodeError:
+            return []
+
+    if len(bboxes) == 4 and isinstance(bboxes[0], Number):
+        bboxes = [bboxes]
+
+    if not isinstance(bboxes, (tuple | list)):
+        return []
+
+    new_bboxes = []
+    for bbox in bboxes:
+        if not isinstance(bbox, (tuple, list)) or len(bbox) != 4:
+            continue
+        if any(not isinstance(coord, (float, int)) for coord in bbox):
+            continue
+        new_bboxes.append(bbox)
+    return new_bboxes
+
+
+def str_to_coords(coord_list, dim=2) -> list:
+    if not isinstance(coord_list, str):
+        return []
+    try:
+        coords = ast.literal_eval(coord_list)
+    except SyntaxError:
+        try:
+            coords = json.loads(coord_list)
+        except json.JSONDecodeError:
+            return []
+
+    new_coords = []
+    for coord in coords:
+        if not isinstance(coord, (tuple, list)) or len(coord) != dim:
+            continue
+        if any(not isinstance(coord, (float, int)) for coord in coord):
+            continue
+        new_coords.append(coord)
+    return new_coords
+
+
+def parse_point_2d_from_xml(xml_string) -> Union[Tuple[float, float], None]:
+    """Parse an (x, y) point from XML formatted like this: <point>x, y</point>"""
+    if not isinstance(xml_string, str):
+        return None
+
+    point_pattern = re.compile(r"<point>(.*?)<\/point>")
+    matches = point_pattern.findall(xml_string)
+    if len(matches) >= 2:
+        return None
+
+    if matches:
+        coords = matches[0].split(",")
+        if len(coords) != 2:
+            return None
+        try:
+            return tuple(float(coord.strip()) for coord in coords)
+        except ValueError:
+            return None
+
+
+def parse_bboxes_from_xml(xml_string: str) -> list:
+
+    if not isinstance(xml_string, str):
+        return []
+
+    bbox_pattern = re.compile(r"<box>(.*?)<\/box>")
+    matches = bbox_pattern.findall(xml_string)
+
+    new_bboxes = []
+    for match in matches:
+
+        coords = match.split(",")
+        if len(coords) != 4:
+            continue
+        try:
+            bbox = tuple(float(coord.strip()) for coord in coords)
+        except ValueError:
+            continue
+
+        if len(bbox) == 4 and all(isinstance(coord, float) for coord in bbox):
+            new_bboxes.append(bbox)
+
+    return new_bboxes
+
+
+MONOSPACE_FONTS = ("Courier New", "DejaVu Sans Mono", "Consolas", "SF Mono")
+
+MONOSPACE_FONT_FILES = []
+for font_name in MONOSPACE_FONTS:
+    try:
+        MONOSPACE_FONT_FILES.append(
+            font_manager.findfont(font_name, fallback_to_default=False)
+        )
+    except ValueError:
+        continue
+
+
+def ascii_text_to_image(
+    text,
+    width,
+    height,
+    font_size=20,
+    padding=10,
+    line_spacing=1,
+    bg_color="white",
+    text_color="black",
+):
+    """Convert ASCII text into an image."""
+    # Split the text into lines
+    lines = text.splitlines()
+
+    # Calculate initial image size based on text
+    char_width = font_size * 0.6  # Approximate width of a character
+    init_width = int(max(len(line) for line in lines) * char_width + 2 * padding)
+    init_height = int(
+        (len(lines) * font_size * line_spacing) + 2 * padding
+    )  # 1.2 for line spacing
+
+    # Create a new image with the calculated size
+    image = Image.new("RGB", (init_width, init_height), color=bg_color)
+    draw = ImageDraw.Draw(image)
+
+    # Load a monospace font
+    font = None
+    for font_name in MONOSPACE_FONT_FILES:
+        try:
+            font = ImageFont.truetype(font_name, font_size)
+            break
+        except IOError:
+            continue
+    if font is None:
+        raise ValueError("Cannot properly render ASCII art: missing monospace font.")
+
+    # Draw each line of text
+    y_text = padding
+    for line in lines:
+        draw.text((padding, y_text), line, font=font, fill=text_color)
+        y_text += font_size * line_spacing  # Move to the next line
+
+    # Resize the image to the specified dimensions
+    image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+    # Convert the image to a NumPy array
+    return image

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/metrics.py

@@ -0,0 +1,102 @@
+from collections.abc import Iterable
+import math
+from numbers import Number
+
+
+def calculate_iou(predicted: Iterable[Number], target: Iterable[Number]):
+    """Calculate the IoU between predicted and target bounding boxes."""
+
+    def box_area(box):
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+    def box_iou(box1, box2):
+        # Calculate intersection coordinates
+        x1 = max(box1[0], box2[0])
+        y1 = max(box1[1], box2[1])
+        x2 = min(box1[2], box2[2])
+        y2 = min(box1[3], box2[3])
+
+        # Calculate intersection area
+        intersection = max(0, x2 - x1) * max(0, y2 - y1)
+
+        # Calculate union area
+        box1_area = box_area(box1)
+        box2_area = box_area(box2)
+        union = box1_area + box2_area - intersection
+
+        # Calculate IoU
+        iou = intersection / union if union > 0 else 0
+        return iou
+
+    # Calculate IoU for each pair of predicted and target boxes
+    iou_scores = []
+    for pred_box in predicted:
+        best_iou = 0
+        for target_box in target:
+            iou = box_iou(pred_box, target_box)
+            best_iou = max(best_iou, iou)
+        iou_scores.append(best_iou)
+
+    return iou_scores
+
+
+def set_relevance_score(denominator_fn, predicted: Iterable, target: Iterable) -> float:
+    """Calculate the relevance score."""
+    pred = set(predicted)
+    tget = set(target)
+    denominator = denominator_fn(pred, tget)
+    if not denominator:
+        return 1
+    return len(pred & tget) / denominator
+
+
+def _union_denominator(pred: set, tget: set) -> int:
+    return len(pred | tget)
+
+
+def _pred_denominator(pred: set, _: set) -> int:
+    return len(pred)
+
+
+def _tget_denominator(_: set, tget: set) -> int:
+    return len(tget)
+
+
+def jaccard_index(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the Jaccard Index."""
+    return set_relevance_score(_union_denominator, predicted, target)
+
+
+def set_precision(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the precision, using sets."""
+    return set_relevance_score(_pred_denominator, predicted, target)
+
+
+def set_recall(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the recall, using sets."""
+    return set_relevance_score(_tget_denominator, predicted, target)
+
+
+def longest_common_prefix(list1: list, list2: list) -> list:
+    """Return the longest common prefix."""
+    index_first_difference = next(
+        (i for i, (a, b) in enumerate(zip(list1, list2)) if a != b),
+        min(len(list1), len(list2)),
+    )
+    return list1[:index_first_difference]
+
+
+def mse(predicted: Number, target: Number) -> Number:
+    """Return the mean squared error."""
+    return (predicted - target) ** 2
+
+
+def point_distance(predicted: tuple[float, ...], target: tuple[float, ...]):
+    """Return the distance between two points."""
+    if len(predicted) != len(target):
+        raise ValueError(
+            "point_distance: Predicted and target points have different dimensions."
+        )
+    return math.sqrt(
+        sum((comp_res - comp_tar) ** 2 for comp_res, comp_tar in zip(predicted, target))
+    )

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/transformations.py

@@ -0,0 +1,120 @@
+"""Like-to-like data transformations."""
+
+import re
+import unicodedata
+
+
+def remove_def_indef_articles(text: str) -> str:
+    """Remove definite and indefinite articles."""
+    text_list = [t for t in text.split(" ") if t.lower() not in {"the", "a"}]
+    return " ".join(text_list)
+
+
+def replace_macrons_with_latex_overline(text: str) -> str:
+    """Replace letters with macrons with the LaTeX bar."""
+    result = []
+    for char in text:
+        if char.isalpha():
+            decomposed = unicodedata.normalize("NFD", char)
+            if len(decomposed) > 1 and decomposed[1] == "\u0304":  # Macron accent
+                result.append(f"\\overline{{{decomposed[0]}}}")
+            else:
+                result.append(char)
+        elif char != "\u0304":
+            result.append(char)
+        else:
+            result[-1] = f"\\overline{{{result[-1]}}}"
+
+    return "".join(result)
+
+
+def fix_overline_underscores(text: str) -> str:
+    """Puts underscores that are outside \overline within overline."""
+    pattern = r"\\overline\{([^}]*)\}_([^{}\\ ]*)"
+    return re.sub(pattern, r"\\overline{\1_\2}", text)
+
+
+# Dictionary mapping Unicode Greek letters to LaTeX equivalents
+greek_to_latex = {
+    # Lowercase Greek letters
+    "α": "\\alpha",
+    "β": "\\beta",
+    "γ": "\\gamma",
+    "δ": "\\delta",
+    "ε": "\\epsilon",
+    "ζ": "\\zeta",
+    "η": "\\eta",
+    "θ": "\\theta",
+    "ι": "\\iota",
+    "κ": "\\kappa",
+    "λ": "\\lambda",
+    "μ": "\\mu",
+    "ν": "\\nu",
+    "ξ": "\\xi",
+    "ο": "\\omicron",
+    "π": "\\pi",
+    "ρ": "\\rho",
+    "σ": "\\sigma",
+    "τ": "\\tau",
+    "υ": "\\upsilon",
+    "φ": "\\phi",
+    "χ": "\\chi",
+    "ψ": "\\psi",
+    "ω": "\\omega",
+    # Uppercase Greek letters
+    "Α": "\\Alpha",
+    "Β": "\\Beta",
+    "Γ": "\\Gamma",
+    "Δ": "\\Delta",
+    "Ε": "\\Epsilon",
+    "Ζ": "\\Zeta",
+    "Η": "\\Eta",
+    "Θ": "\\Theta",
+    "Ι": "\\Iota",
+    "Κ": "\\Kappa",
+    "Λ": "\\Lambda",
+    "Μ": "\\Mu",
+    "Ν": "\\Nu",
+    "Ξ": "\\Xi",
+    "Ο": "\\Omicron",
+    "Π": "\\Pi",
+    "Ρ": "\\Rho",
+    "Σ": "\\Sigma",
+    "Τ": "\\Tau",
+    "Υ": "\\Upsilon",
+    "Φ": "\\Phi",
+    "Χ": "\\Chi",
+    "Ψ": "\\Psi",
+    "Ω": "\\Omega",
+}
+
+
+def replace_greek_letters(text: str) -> str:
+    """Replace Greek letters in Unicode with their LaTeX equivalents."""
+    return re.sub(r"[α-ωΑ-Ω]", lambda match: greek_to_latex[match.group()] + " ", text)
+
+
+def remove_latex_math_delimiters(latex_str):
+    # Pattern to match \begin{...}[...] and \end{...}[...] commands
+    env_pattern = r"\\(begin|end)\{.*?\}(?:\[[^\[\]]*\])?"
+    latex_str = re.sub(env_pattern, "", latex_str)
+
+    # Remove \( and \)
+    inline_math_pattern = r"\\\(|\\\)"
+    latex_str = re.sub(inline_math_pattern, "", latex_str)
+
+    # Remove \[ and \]
+    display_math_pattern = r"\\\[|\\\]"
+    latex_str = re.sub(display_math_pattern, "", latex_str)
+
+    return latex_str
+
+
+def normalize_latex(text: str) -> str:
+    """Normalize the LaTeX expression."""
+    text = text.replace("\\bar", "\\overline")
+    text = replace_macrons_with_latex_overline(text)
+    text = fix_overline_underscores(text)
+    text = replace_greek_letters(text)
+    text = remove_latex_math_delimiters(text)
+    return text

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_equality.py

@@ -0,0 +1,44 @@
+from .common.conversions import cast_to_dict
+from .simple_str_match import ExactStrMatch
+
+
+class DictEquality:
+    """Calculates the exact string match across the dict.
+
+    1. Calculates the exact match for all keys in the solution
+    2. Calculates the total, then divides by the size of the solution
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        return 1 if responses == targets else 0
+
+
+class DictPrecision:
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        if len(responses) == 0:
+            return 0
+
+        matched = 0
+        for key, val in responses.items():
+            if key in targets:
+                if ExactStrMatch.match(val, targets[key]):
+                    matched += 1
+
+        return matched / len(responses)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py

@@ -0,0 +1,27 @@
+from .common.conversions import cast_to_dict
+from .exact_str_match import ExactStrMatch
+
+
+class DictExactStrMatchAggRecall:
+    """Calculates the exact string match across the dict.
+
+    1. Calculates the exact match for all keys in the solution
+    2. Calculates the total, then divides by the size of the solution
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        num_keys = 0
+        total_score = 0
+        for key, answer in targets.items():
+            total_score += ExactStrMatch.match(responses.get(key), answer)
+            num_keys += 1
+
+        return total_score / num_keys

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py

@@ -0,0 +1,253 @@
+import re
+from .simple_str_match import SimpleStrMatch
+
+from sympy.parsing.latex import parse_latex
+import math
+import multiprocessing
+
+import signal
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    raise TimeoutException()
+
+
+E = 2.718
+
+############## Begin
+# Numerical comparison from https://github.com/TIGER-AI-Lab/MAmmoTH/blob/main/math_eval/number_utils.py
+
+
+def run_eval(expression, output):
+    try:
+        # Safely evaluate the expression
+        result = eval(expression)
+        output.put(result)
+    except Exception as e:
+        output.put(e)
+
+
+def eval_with_timeout(expression, timeout=5):
+    # Create a multiprocessing.Queue to receive the output
+    output = multiprocessing.Queue()
+
+    # Define and start the process
+    process = multiprocessing.Process(target=run_eval, args=(expression, output))
+    process.start()
+
+    # Wait for the process to complete or timeout
+    process.join(timeout)
+
+    if process.is_alive():
+        # Terminate the process
+        process.terminate()
+        process.join()
+        return "Timeout or error during evaluation"
+
+    # Get result from the queue
+    try:
+        return output.get_nowait()
+    except Exception as e:
+        return "Error retrieving result"
+
+
+def compare_two_list(pred, gt):
+    if not isinstance(pred, list):
+        return False
+    elif len(pred) != len(gt):
+        return False
+    elif any([not isinstance(x, (int, float)) for x in pred]):
+        return False
+    else:
+        pred = sorted(pred)
+        gt = sorted(gt)
+        return all([compare_two_numbers(p, g) for p, g in zip(pred, gt)])
+
+
+def compare_two_numbers(p, gt):
+    try:
+        if math.isnan(p):
+            return False
+        else:
+            return within_eps(pred=p, gt=gt)
+    except Exception:
+        return False
+
+
+def within_eps(pred: float, gt: float):
+    eps = abs(gt) * 0.01
+    if pred >= gt - eps and pred <= gt + eps:
+        return True
+    else:
+        return False
+
+
+def clean_units(pred_str: str):
+    """Clean the units in the number."""
+
+    def convert_pi_to_number(code_string):
+        code_string = code_string.replace("\\pi", "π")
+        # Replace \pi or π not preceded by a digit or } with 3.14
+        code_string = re.sub(r"(?<![\d}])\\?π", "3.14", code_string)
+        # Replace instances where π is preceded by a digit but without a multiplication symbol, e.g., "3π" -> "3*3.14"
+        code_string = re.sub(r"(\d)(\\?π)", r"\1*3.14", code_string)
+        # Handle cases where π is within braces or followed by a multiplication symbol
+        # This replaces "{π}" with "3.14" directly and "3*π" with "3*3.14"
+        code_string = re.sub(r"\{(\\?π)\}", "3.14", code_string)
+        code_string = re.sub(r"\*(\\?π)", "*3.14", code_string)
+        return code_string
+
+    pred_str = convert_pi_to_number(pred_str)
+    pred_str = pred_str.replace("%", "/100")
+    pred_str = pred_str.replace("$", "")
+    pred_str = pred_str.replace("¥", "")
+    pred_str = pred_str.replace("°C", "")
+    pred_str = pred_str.replace(" C", "")
+    pred_str = pred_str.replace("°", "")
+    return pred_str
+
+
+def number_it(num):
+    if isinstance(num, (int, float)):
+        return num
+
+    num = clean_units(num)
+    try:
+        num = str(parse_latex(num))
+    except Exception:
+        pass
+
+    if floatify(num) is not None:
+        return floatify(num)
+    else:
+        try:
+            num = eval_with_timeout(num)
+            if isinstance(num, list) or isinstance(num, tuple):
+                return num  # return num list
+            if floatify(num) is not None:
+                return floatify(num)
+            else:
+                return None
+        except Exception:
+            return None
+
+
+def floatify(num: str):
+    try:
+        num = float(num)
+        if num.is_integer():
+            return round(num)
+        else:
+            return num
+    except Exception:
+        return None
+
+
+def remove_latex_math_brackets(latex_str):
+    """
+    Removes LaTeX math mode delimiters (\( ... \) and \[ ... \]) from a string
+    while preserving the contents inside the delimiters.
+    If no such delimiters are found, the original string is returned.
+    """
+    # Regex pattern for inline math \( ... \)
+    inline_pattern = re.compile(r"\\\((.*?)\\\)")
+    # Regex pattern for TeX inline math $...$
+    tex_inline_pattern = re.compile(r"$(.*?)$")
+    # Regex pattern for display math \[ ... \]
+    display_pattern = re.compile(r"\\\[(.*?)\\\]")
+
+    latex_patterns = (inline_pattern, tex_inline_pattern, display_pattern)
+
+    if any(pattern.search(latex_str) for pattern in latex_patterns):
+        # Remove inline math mode brackets
+        latex_str = inline_pattern.sub(r"\1", latex_str)
+        # Remove display math mode brackets
+        latex_str = display_pattern.sub(r"\1", latex_str)
+    return latex_str
+
+
+def parse_assignment(expression):
+    # match the content after "=", "≈", or "\approx"
+    pattern = r"(?:=|≈|\\approx)\s*(.+)"
+
+    match = re.search(pattern, expression)
+    if match:
+        # Return the content after the sign
+        return match.group(1).strip()
+    else:
+        return expression
+
+
+############## End
+
+
+class GeneralSingleNumericalMatch:
+    """
+    Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        if not isinstance(responses, str):
+            responses = str(responses)
+        responses = remove_latex_math_brackets(responses)
+        responses = parse_assignment(responses)
+        targets = remove_latex_math_brackets(targets)
+        targets = parse_assignment(targets)
+        res = number_it(responses)
+        tgt = number_it(targets)
+
+        if res is not None and tgt is not None:
+            if (
+                isinstance(res, list)
+                and isinstance(tgt, list)
+                or isinstance(res, tuple)
+                and isinstance(tgt, tuple)
+            ):
+                score = float(compare_two_list(res, tgt))
+            else:
+                score = float(compare_two_numbers(res, tgt))
+        else:
+            score = SimpleStrMatch.match(responses, targets)
+
+        return score
+
+
+class BoxedSingleNumericalMatch:
+    """
+    Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+    """
+
+    @staticmethod
+    def parse_boxed_content(text):
+        ###
+        #   Pattern: r'\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}':
+        #    \\boxed\{: Matches the literal \boxed{.
+        #    ((?:[^\{\}]+|\{[^\{\}]*\})*): This part matches the content inside the \boxed{}.
+        #    (?:...): A non-capturing group that allows us to match both non-brace content and brace-enclosed content.
+        #    [^\{\}]+: Matches any content that is not an opening { or closing } brace.
+        #    \{[^\{\}]*\}: Matches balanced braces containing non-nested content (e.g., {5} or {3} in the LaTeX expression \frac{5}{3}).
+        ###
+        pattern = r"\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}"
+        match = re.search(pattern, text)
+        return match.group(1) if match else text
+
+    @classmethod
+    def match(cls, responses, targets, timeout_duration=10) -> float:
+        if not isinstance(responses, str):
+            responses = str(responses)
+        signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(timeout_duration)  # Set the timeout duration in seconds
+        try:
+            parsed_res = cls.parse_boxed_content(responses)
+            targets = cls.parse_boxed_content(targets)
+            score = GeneralSingleNumericalMatch.match(parsed_res, targets)
+            return score
+        except TimeoutException:
+            return SimpleStrMatch.match(responses, targets)
+        finally:
+            signal.alarm(0)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py

@@ -0,0 +1,15 @@
+from .common.conversions import str_to_list
+from .common.metrics import longest_common_prefix
+
+
+class LongestCommonListPrefixRatio:
+    """Determines how much of the first part of the list
+    was predicted correctly.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+        return len(longest_common_prefix(responses, targets)) / len(targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/mse.py

@@ -0,0 +1,64 @@
+import ast
+import numpy as np
+import math
+from .common.metrics import mse
+from .common.conversions import str_to_list
+
+
+class MSE:
+    """Mean Squared Error."""
+
+    @staticmethod
+    def match(response: str, correct_answer: str) -> int:
+        """Return the mean squared error."""
+        try:
+            return mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+        except (SyntaxError, ValueError):
+            return 0
+
+
+class NormalizedRMSE:
+    """Mean Squared Error."""
+
+    MIN = 0.0
+    MAX = 0.1
+
+    @classmethod
+    def match(cls, response: str, correct_answer: str) -> int:
+        """Return the mean squared error."""
+        try:
+            mse_val = mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+            rmse = np.clip(np.sqrt(mse_val), cls.MIN, cls.MAX)
+            norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+            return norm_rmse
+        except (SyntaxError, ValueError):
+            return 0
+
+
+class AngleSeqFloatRMSE:
+    """Whether the sequence of numbers is close enough to the real answer."""
+
+    MIN = 0.0
+    MAX = 10.0
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Determines whether the sequence of floats are close enough to the real answer."""
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+
+        if len(responses) != len(targets):
+            return 0
+
+        try:
+            res = np.array(responses)
+            tgt = np.array(targets)
+            rmse = np.sqrt(mse(res, tgt)).sum() / len(targets)
+        except:  # cannot obtain the rmse from the response, return 0
+            return 0
+
+        rmse = np.clip(rmse, cls.MIN, cls.MAX)
+        norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+        if math.isnan(norm_rmse):
+            return 0
+        return norm_rmse

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py

@@ -0,0 +1,26 @@
+from numbers import Number
+from .common.conversions import str_to_iterable
+from .simple_str_match import SimpleStrMatch
+
+
+def replace_potential_chinese_comma(input_string):
+    return input_string.replace("，", ",")
+
+
+class MultipleReferencePhraseEval:
+    """
+    Check the response with multiple correct references
+    As long as one is matched, the score is 1, otherwise the score is 0
+    """
+
+    @staticmethod
+    def match(response, targets) -> Number:
+        targets = replace_potential_chinese_comma(targets)
+        refs = str_to_iterable(list, targets)
+        matched = False
+        for ref in refs:
+            str_ref = ref if isinstance(ref, str) else str(ref)
+            if SimpleStrMatch.match(response, str_ref):
+                matched = True
+                break
+        return 1 if matched else 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py

@@ -0,0 +1,104 @@
+import logging
+import ast
+from .common.conversions import str_to_bboxes
+from .common.metrics import calculate_iou
+import numpy as np
+
+
+class NbboxIouTuple:
+    """Calculates the IoU, for all bounding boxes, for all predicted bounding boxes.
+    For each predicted bounding box, it uses the IoU with the target bounding box with
+    the highest IoU.
+
+    Assumes that co-ordinates are normalized between 0 and 1 and that the bounding boxes
+    are of the form (x1, y1, x2, y2), where (x1, y1) is the top-left corner and (x2, y2)
+    is the bottom-right.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        logging.debug(f"{responses=}, {targets=}")
+        if not isinstance(responses, (tuple | list)):
+            responses = str_to_bboxes(responses)
+        if not isinstance(targets, (tuple | list)):
+            targets = str_to_bboxes(targets)
+
+        try:
+            iou_scores = calculate_iou(responses, targets)
+        except:
+            return 0
+
+        if not iou_scores:
+            return 0
+
+        # Take the mean IoU score for now.
+        return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSingle:
+    """
+    Single bbox IoU metric
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        logging.debug(f"{responses=}, {targets=}")
+        targets = ast.literal_eval(targets)
+        try:
+            responses = ast.literal_eval(responses)
+        except SyntaxError:
+            return 0
+
+        try:
+            iou_scores = calculate_iou(
+                [
+                    responses,
+                ],
+                [
+                    targets,
+                ],
+            )
+            if not iou_scores:
+                return 0
+        except:
+            return 0
+
+        # Take the mean IoU score for now.
+        return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSequence:
+    """
+    Metric for a sequence of bboxes (used for single object tracking).
+    The number of predicted boxes must match the ground truth.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if not isinstance(responses, (tuple | list)):
+            responses = str(responses) if not isinstance(responses, str) else responses
+            responses = str_to_bboxes(responses)
+        if not isinstance(targets, (tuple | list)):
+            targets = str_to_bboxes(targets)
+
+        if len(targets) != len(responses):
+            return 0
+
+        scores = []
+        for res, tgt in zip(responses, targets):
+            scores.append(
+                calculate_iou(
+                    [
+                        res,
+                    ],
+                    [
+                        tgt,
+                    ],
+                )
+            )
+        avg_iou = np.mean(scores)
+
+        return avg_iou

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/near_str_match.py

@@ -0,0 +1,23 @@
+import rapidfuzz
+import unidecode
+from .common.transformations import remove_def_indef_articles
+
+
+def approximate(text: str) -> str:
+    """Return an approximation of the original string."""
+    return unidecode.unidecode(remove_def_indef_articles(text)).lower()
+
+
+class NearStrMatch:
+    """Near string matching."""
+
+    @staticmethod
+    def match(response, correct_answer: str, threshold=0.9) -> int:
+        """Simple string match between response and correct_answer."""
+        if not isinstance(response, str) or not isinstance(correct_answer, str):
+            return 0
+        response = approximate(response)
+        correct_answer = approximate(correct_answer)
+        return rapidfuzz.distance.DamerauLevenshtein.normalized_similarity(
+            response, correct_answer, score_cutoff=threshold
+        )

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py

@@ -0,0 +1,22 @@
+import ast
+import math
+from numbers import Number
+
+
+class NumberRelDiffRatio:
+    """Number relative difference ratio scoring = min(0, 1 - |pred - gt| / gt)"""
+
+    @staticmethod
+    def match(response: str | Number, correct_answer: str) -> int:
+        """Return the relative difference ratio."""
+        try:
+            if isinstance(response, Number):
+                pred = response
+            else:
+                pred = ast.literal_eval(response)
+            if not isinstance(pred, Number):
+                return 0
+            gt = ast.literal_eval(correct_answer)
+            return max(0, 1 - math.fabs((pred - gt) / gt))
+        except (SyntaxError, ValueError):
+            return 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py

@@ -0,0 +1,31 @@
+import ast
+
+
+class PositiveIntMatch:
+    """Positive int matching."""
+
+    @staticmethod
+    def match(response: str, correct_answer: str) -> int:
+        """If the correct answer or response is a positive integer, then it returns if the predicted and correct answers are identical.
+
+        Otherwise, it returns -1.
+        """
+        try:
+            response_obj = ast.literal_eval(response)
+        except (SyntaxError, ValueError):
+            return 0
+
+        if not correct_answer:
+            return 0
+
+        correct_answer_obj = ast.literal_eval(correct_answer)
+
+        assert isinstance(correct_answer_obj, int)
+        if not isinstance(response_obj, int):
+            return 0
+
+        # We only want to score the fields with a positive amount
+        if correct_answer_obj <= 0 and response_obj <= 0:
+            return -1
+
+        return 1 if response_obj == correct_answer_obj else 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/set_precision.py

@@ -0,0 +1,16 @@
+from .common.conversions import cast_to_set
+from .common.metrics import set_precision
+
+
+class SetPrecision:
+    """Calculates the set precision for iterables."""
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if responses is None:
+            return 0
+        responses = cast_to_set(responses)
+        targets = cast_to_set(targets)
+
+        return set_precision(responses, targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py

@@ -0,0 +1,266 @@
+import re
+
+PARAM_LIST_MATCHER = re.compile(r"((?:\?\S+\s*)+)(?:-\s+([^\?$]+)\s*)?")
+PARAM_NAME_MATCHER = re.compile(r"\?([^\s\?\)]+)\s*")
+
+
+##### Parsing functions and parentheses matching
+def parse_pddl_param_list(s):
+    s = s.strip()
+    assert s[0] == "(" and s[-1] == ")"
+    s = s[1:-1]
+    param_type_dict = {}
+    for params, p_type in PARAM_LIST_MATCHER.findall(s):
+        for p in PARAM_NAME_MATCHER.findall(params):
+            p_type = p_type.strip()
+            if p_type.startswith("("):
+                p_type = p_type[1:-1].strip()
+                assert "either"
+                param_type_dict[p] = re.split(r"\s+", p_type)[1:]
+            else:
+                param_type_dict[p] = p_type
+    return s.split("?")[0].strip(), param_type_dict
+
+
+def parse_outer_inner_str(s, str_ender, inner_starter, inner_ender):
+    inner_count = 0
+    start_id = 0
+    matched_str = []
+    for i, c in enumerate(s):
+        if inner_count == 0 and c == str_ender:
+            return s[: i + 1], matched_str, i + 1
+        elif c == inner_starter:
+            if inner_count == 0:
+                start_id = i
+            inner_count += 1
+        elif c == inner_ender:
+            inner_count -= 1
+            if inner_count == 0:
+                matched_str.append(s[start_id : i + 1])
+    return s, matched_str, len(s)
+
+
+def parse_pddl_attr_from_string(
+    s,
+    attr_starter="(:",
+    attr_ender=")",
+    inner_starter="(",
+    inner_ender=")",
+    overlap=False,
+):
+    s_attr = s.split(attr_starter)
+    if len(s_attr) == 1:
+        return "", []
+    elif len(s_attr) == 2:
+        outer_str, inner_str, _ = parse_outer_inner_str(
+            s_attr[1], attr_ender, inner_starter, inner_ender
+        )
+        return attr_starter + outer_str, inner_str
+    else:
+        matched_dict = {}
+        outer_list = []
+        if not overlap:
+            while len(s.split(attr_starter)) > 1:
+                s = s.split(attr_starter, 1)[1]
+                name = re.split(r"\s+", s.strip())[0]
+                outer_str, inner_str, end_point = parse_outer_inner_str(
+                    s, attr_ender, inner_starter, inner_ender
+                )
+                outer_list.append(attr_starter + outer_str)
+                matched_dict[name] = inner_str
+                s = s[end_point:]
+        else:
+            for seg in s_attr[1:]:
+                name = re.split(r"\s+", seg.strip())[0]
+                outer_str, inner_str, _ = parse_outer_inner_str(
+                    seg, attr_ender, inner_starter, inner_ender
+                )
+                outer_list.append(attr_starter + outer_str)
+                matched_dict[name] = inner_str
+        return outer_list, matched_dict
+
+
+def remove_type_in_cnf(s):
+    s_split_type = s.split(" - ")
+    if len(s_split_type) > 1:
+        for i in range(1, len(s_split_type)):
+            if len(s_split_type[i].strip().split(")")[0].split()) == 1:
+                s_split_type[i] = ")" + s_split_type[i].strip().split(")", 1)[1]
+            else:
+                s_split_type[i] = " " + s_split_type[i].strip().split(" ", 1)[1]
+        return "".join(s_split_type).strip()
+    else:
+        return s
+
+
+def split_cnf_by_parentheses(s):
+    assert s.startswith("(and")
+    matches = set()
+    p_count = 0
+    clause_start_id = 0
+    for i in range(len(s)):
+        if s[i] == "(":
+            p_count += 1
+            if p_count == 2:
+                clause_start_id = i
+        elif s[i] == ")":
+            p_count -= 1
+            if p_count == 0:
+                break
+            elif p_count == 1:
+                matches.add(remove_type_in_cnf(s[clause_start_id : i + 1]))
+    return matches
+
+
+##### End of parsing functions
+
+
+####### Domain (the env for each planning task)
+class Domain:
+    def __init__(self, name, domain_pddl):
+        # self.name = name
+
+        # Domain files
+        self.domain_pddl = domain_pddl
+        self.action_name, self.action_params, self.action_params_dict = (
+            self.get_domain_action()
+        )
+        self.gt_cond_dict = self.parse_gt_pre_post_cond()
+
+    def get_domain_action(self):
+        action_pddl_str_list, all_actions = parse_pddl_attr_from_string(
+            self.domain_pddl, attr_starter="(:action"
+        )
+        action_name, action_params, action_params_dict = [], [], []
+        for action_pddl_str, (name, action_attr) in zip(
+            action_pddl_str_list, all_actions.items()
+        ):
+            assert len(action_attr) == 3
+            param_str, pre_cond_str, post_cond_str = action_attr
+            action_name.append(name)
+            action_params.append(param_str)
+            action_params_dict.append(parse_pddl_param_list(param_str)[1])
+        return action_name, action_params, action_params_dict
+
+    def parse_gt_pre_post_cond(self):
+        cond_dict = {}
+        for a in self.action_name:
+            act_str = self.domain_pddl.split(f"(:action {a}")[1]
+            for postfix in ["pre", "post"]:
+                split_tag = ":precondition" if postfix == "pre" else ":effect"
+                cond_str = act_str.split(split_tag)[1].strip()
+                if cond_str.startswith("(and"):
+                    cond_dict[f"{a}_{postfix}"] = split_cnf_by_parentheses(cond_str)
+                else:
+                    cond_dict[f"{a}_{postfix}"] = {cond_str.split(")")[0].strip() + ")"}
+                cond_dict[f"{a}_{postfix}"] = sorted(
+                    list(cond_dict[f"{a}_{postfix}"]),
+                    key=lambda x: 0 if x.startswith("(not ") else 1,
+                )
+        return cond_dict
+
+
+##### Transition functions
+def construct_param_to_obj(domain, action):
+    action = action[1:-1]
+    a_name = action.split(" ")[0].strip()
+    objs = action.split(" ")[1:]
+    a_index = domain.action_name.index(a_name)
+    assert len(objs) == len(domain.action_params_dict[a_index])
+    return {p: obj for p, obj in zip(domain.action_params_dict[a_index], objs)}, a_name
+
+
+def state_transition(current_state, effects, param_to_obj):
+    for obj_cond in effects:
+        for param in param_to_obj:
+            obj_cond = re.sub(
+                r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+            )
+        _, reversed_cond = parse_pddl_attr_from_string(obj_cond, attr_starter="(not ")
+        if reversed_cond:
+            assert len(reversed_cond) == 1
+            if reversed_cond[0] in current_state:
+                current_state.remove(reversed_cond[0])
+        elif obj_cond.strip() not in current_state:
+            current_state.append(obj_cond)
+    return current_state
+
+
+def check_pre_conds_satisfy(current_state, pre_conds, param_to_obj):
+    for obj_cond in pre_conds:
+        for param in param_to_obj:
+            obj_cond = re.sub(
+                r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+            )
+        if (obj_cond.startswith("(not ") and obj_cond in current_state) or (
+            not obj_cond.startswith("(not ") and obj_cond not in current_state
+        ):
+            return False
+    return True
+
+
+##### End of transition functions
+
+
+class SymbolicPlanningMetricTest:
+    """An example metric for symbolic planning tasks"""
+
+    @classmethod
+    def match(cls, response, eval_context, task_info=None):
+        ## Initialize domain
+        # task_name = task_info["task_name"]
+        domain_pddl = eval_context["domain_pddl"]
+        domain = Domain(" ", domain_pddl)
+
+        ## Parse trajectory, setup initial and goal state
+        # response = eval_context["gt_plan"]  # for debug
+        match response:
+            case str():
+                candidates = response.split("\n")
+            case tuple() | list():
+                candidates = list(response)
+            case _:
+                raise ValueError(
+                    f"`response` has unsupported type: {type(response)=}, {response=}"
+                )
+        cand_traj = [cand_a.strip() for cand_a in candidates if cand_a.startswith("(")]
+        try:
+            task_pddl = eval_context["task_pddl"]
+            cur_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(:init")[1]
+            goal_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(and")[1]
+        except IndexError:
+            score = 0
+            return score
+
+        score = 1
+        try:
+            ## State transitions and check if satisfy the preconditions
+            for cand_a in cand_traj:
+                param_to_obj, a_name = construct_param_to_obj(domain, cand_a)
+                if not check_pre_conds_satisfy(
+                    cur_state, domain.gt_cond_dict[f"{a_name}_pre"], param_to_obj
+                ):
+                    print(f"precondition of the action {cand_a} is not satisfied!")
+                    score = 0
+                    break
+                cur_state = state_transition(
+                    cur_state, domain.gt_cond_dict[f"{a_name}_post"], param_to_obj
+                )
+
+            ## Check if goal conditions are reached in the final state
+            if score == 1:
+                for g_state in goal_state:
+                    if (g_state.startswith("(not ") and g_state in cur_state) or (
+                        not g_state.startswith("(not ") and g_state not in cur_state
+                    ):
+                        print(f"goal state {g_state} is not reached!")
+                        score = 0
+                        break
+        except ValueError:
+            # grammar error in execution
+            score = 0
+        except AssertionError:
+            # assertion error in functions
+            score = 0
+
+        return score