AnnotationDataManager.py

Go to the documentation of this file.

import copy
import os
import re
 
import cv2
import numpy as np
 
import smdataset.utils_data as utils
 
 
class AnnotationDataManager:
    """
    세이프모션 행동 데이터를 관리하는 클래스
    데이터 불러오기, 저장하기, 업데이트(데이터 변경), 프레임단위로 데이터 get, 추적 아이디 단위로 get 등의 기능 제공
    args:
        anno_path (str) : 어노테이션 파일(json 파일) 경로
        save_path (str) : 저장 경로, 설정하지 않으면 anno_path에 저장됨
    """
    json_version = 10 #json 파일 버전
    anno_path = None
    image_base_path = None
    base_path = None
    dataset = None
    anno_in_image = None
    anno_ids = None
    image_ids = None
    image_filenames = None
 
    image_idx = None
    image_id = None
    anno_idx = None    
    anno_id = None
    anno_idx_in_image = None
 
    def __init__(self, anno_path=None, save_path=None):
        self.init()
        if anno_path is not None:
            self.load_annotation(anno_path, save_path=save_path)
 
    def init(self):
        """
        초기화 함수, 멤버변수 값을 초기화 함
        """
 
        #파일 정보
        self.json_versionjson_version = 10 #json 파일 버전, json 파일에 들어있는 데이터 및 파일 포맷관련
        self.label_map_version = 20 #레이블 맵 버전, 클래스 구조 관련
        self.anno_path = None #로드하는 데이터 경로
        self.save_path = None #저장하는 경로
        self.image_base_path = None #이미지 폴더
        
        #데이터 정보
        self.dataset = None #json 파일 내용
        self.anno_in_image = None #dataset의 annotations 값들을 프레임 단위로 구조를 변환한 데이터
        self.anno_ids = None #어노테이션 아이디 리스트, 박스마다 어노테이션 아이디가 부여되어 있음
        self.image_ids = None #이미지 아이디 리스트, 해당 변수기반으로 프레임 인덱스를 알아낼 수 있음
        self.image_filenames = None #이미지 파일 이름 리스트
 
        #현재 프레임 및 선택한 박스 정보
        self.image_idx = None #현재 이미지 프레임 인덱스
        self.anno_idx = None #현재 선택된 어노테이션(박스) 인덱스
        self.anno_idx_in_image = None #현재 프레임의 어노테이션 인덱스, 현재 프레임에 있는 어노테이션중에 몇번째 데이터인지 알수 있는 변수
        self.image_id = None #현재 프레임의 이미지 아이디
        self.anno_id = None #현재 선택된 어노테이션(박스)의 아이디
        
    def load_annotation(self, anno_path, image_base=None, program_label_map_version=None, save_path=None):
        """
        어노테이션 파일 로드
        데이터를 로드하고 프레임 단위로 데이터 구조를 변경해둠
        args:
            anno_path (str) : json 파일의 경로
            image_base (str) : 이미지 베이스 경로 설정 가능, 설정하지 않으면 기본 디폴트 값을 사용함
            program_label_map_version (str) : 라벨링 프로그램의 레이블맵 버전, 설정하지 않는다면 json 파일에 값을 사용
            save_path (str) : 저장 경로 설정, 설정하지 않는다면 anno_path로 설정됨
        """
        self.init()
        self.anno_path = anno_path
        
        (self.json_versionjson_version, 
        self.label_map_version,
        self.base_path,
        self.image_base_path,
        self.dataset) = utils.load_annotation(anno_path)
 
        if image_base != None:
            image_folder = utils.make_image_folder(self.json_versionjson_version, anno_path)
            self.image_base_path = os.path.join(image_base, image_folder)
 
        if program_label_map_version is not None:
            if self.label_map_version != program_label_map_version:
                self.label_map_version = program_label_map_version
                self.dataset['info']['label_map_version'] = program_label_map_version/10
 
        (self.anno_in_image, 
        self.anno_ids,
        self.image_ids,
        self.image_filenames) = self.cvt_data_format(self.dataset)
        
        if save_path is None:
            self.save_path = self.anno_path
        else:
            self.save_path = save_path
 
    def cvt_data_format(self, dataset):
        """
        프레임 단위로 데이터 구조를 변경하는 기능
        args:
            dataset (dict) : 어노테이션 데이터
                info : json 파일의 기본 정보가 들어있음
                images : 이미지 아이디, 이름 및 기타 정보
                annotations : 라벨링된 데이터, 박스마다 데이터가 들어있음
                    대표 정보 : 어노테이션 아이디, 박스정보(x, y, w, h), 키포인트, 액션 라벨 등
        return:
            anno_in_image (dict): 프레임 단위로 어노테이션(박스) 정보를 저장한 변수
                key (int): 이미지 아이디
                value (list[dict]): 해당 프레임의 어노테이션(박스) 정보 리스트
            anno_ids (list): 어노테이션 아이디 리스트
            image_ids (list): 이미지 아이디 리스트
            image_filenames (list): 이미지 이름 리스트
        """
        image_ids = []
        image_filenames = []
        anno_in_image = {}
        
        for img in dataset['images']:
            image_ids.append(img['id'])
            image_filenames.append(img['file_name'])
            anno_in_image[img['id']] = []
 
        anno_ids = []
        for anno in dataset['annotations']:
            anno_in_image[anno['image_id']].append(copy.deepcopy(anno))
            anno_ids.append(anno['id'])
 
        return anno_in_image, anno_ids, image_ids, image_filenames
 
    def save_annotation(self):
        """
        데이터 저장 기능
        """
        utils.save_json(self.save_path, self.dataset)
        
    #===========cur annotation data setting========#
    def init_annotation(self):
        """
        현재 프레임 정보 초기화 기능
        맨 첫프레임, 첫번째 어노테이션(박스) 정보로 셋팅함
        첫프레임에 어노테이션 정보가 없다면 관련 변수는 None으로 셋팅됨
        """
        self.image_idx = None
        self.image_id = None
        self.anno_id = None
        self.anno_idx = None
        self.anno_idx_in_image = None
        if len(self.image_ids) == 0:
            return
        
        self.image_idx = 0
        self.image_id = self.image_ids[0]
 
        if len(self.anno_in_image[self.image_id]) > 0:
            self.anno_idx = 0
            self.anno_idx_in_image = 0
            self.anno_id = self.dataset['annotations'][0]['id']
 
    def set_anno_idx_in_image(self, anno_idx_in_image):
        """
        현재 프레임의 어노테이션(박스) 인덱스 기준으로 관련 데이터를 셋팅함
        args:
            anno_idx_in_image (int) : 설정하기 위한 현재 프레임의 어노테이션(박스) 인덱스
        """
        if self.get_number_of_anno_in_image() > anno_idx_in_image:
            self.anno_idx_in_image = anno_idx_in_image
            self.anno_id = self.anno_in_image[self.image_id][anno_idx_in_image]['id']
            self.anno_idx = self.anno_ids.index(self.anno_id)
 
    def set_annotation_by_anno_index(self, anno_idx):
        """
        어노테이션(박스) 인덱스 기준으로 현재 정보를 셋팅함
        args:
            anno_idx (int) : 셋팅하려는 어노테이션(박스) 인덱스
        return (bool): 이미지 변경 유무
        """
        pre_image_idx = self.image_idx
        self.image_id = self.dataset['annotations'][anno_idx]['image_id']
        self.image_idx = self.image_ids.index(self.image_id)
 
        self.anno_idx = anno_idx
        self.anno_id = self.anno_ids[anno_idx]
        self.anno_idx_in_image = self.get_anno_index_in_image(self.anno_id, self.image_id)
 
        return pre_image_idx != self.image_idx
 
    def set_annotation_by_image_index(self, image_idx, use_track_id=False):
        """
        이미지 인덱스를 기준으로 현재 정보를 셋팅함
        추적아이디 사용을 설정하면 현재 선택된 추적아이디와 같은 어노테이션 정보로 셋팅함
        args:
            image_idx (int) : 셋팅하려는 이미지 인덱스
            use_track_id (bool) : 추적아이디 사용 여부
        return (bool): 이미지 변경 유무
        """
        pre_image_idx = self.image_idx
        self.image_id = self.image_ids[image_idx]
 
        track_id = None
        if use_track_id and self.anno_idx is not None:
            track_id = self.dataset['annotations'][self.anno_idx]['track_id']
 
        anno_idx_in_image = 0
        if self.image_idx > image_idx:
            anno_idx_in_image = max(0, len(self.anno_in_image[self.image_id])-1)
 
        if track_id is not None:
            for idx, anno in enumerate(self.anno_in_image[self.image_id]):
                if anno["track_id"] == track_id:
                    anno_idx_in_image = idx
                    break
 
        self.image_idx = image_idx
        self.anno_idx = self.get_anno_index(self.image_id, anno_idx_in_image)
        if self.anno_idx is None:
            self.anno_id = None
            self.anno_idx_in_image = None
        else:
            self.anno_id = self.anno_ids[self.anno_idx]
            self.anno_idx_in_image = anno_idx_in_image
 
        return pre_image_idx != self.image_idx
    
    def move_anno_right(self):
        """
        다음 어노테이션(박스)로 이동함
        return (bool): 이미지 변경 유무
        """
        check_change_image = True
        if self.check_anno_pose_in_frame(-1):
            self.set_annotation_by_image_index(self.image_idx+1, use_track_id=False)
        else:
            check_change_image = self.set_annotation_by_anno_index(self.anno_idx+1)
 
        return check_change_image
 
    def move_anno_left(self):
        """
        이전 어노테이션(박스)로 이동함
        return (bool): 이미지 변경 유무
        """
        check_change_image = True
        if self.check_anno_pose_in_frame(0):
            self.set_annotation_by_image_index(self.image_idx-1, use_track_id=False)
        else:
            check_change_image = self.set_annotation_by_anno_index(self.anno_idx-1)
            
        return check_change_image
 
    def move_image_right(self, use_track_id=False):
        """
        다음 이미지로 이동함
        """
        if self.get_number_of_image() <= (self.image_idx+1):
            return
        self.set_annotation_by_image_index(self.image_idx+1, use_track_id=use_track_id)
 
    def move_image_left(self, use_track_id=False):
        """
        이전 이미지로 이동함
        """
        if self.image_idx == 0:
            return
        self.set_annotation_by_image_index(self.image_idx-1, use_track_id=use_track_id)
    #===============================================#
 
 
    #=====================check=====================#
    def check_anno_pose_in_frame(self, check_index):
        """
        현재 프레임에서 현재 선택되어 있는 어노테이션(박스)이 처음인지 마지막인지 확인하는 기능
        args:
            check_index (int) : 첫프레임 체크인지 마지막 프레임 체크인지 설정하는 파라미터
                0 : 첫프레임인지 확인
                -1 : 마지막 프레임인지 확인
        return (bool): 확인 정보
        """
        check = True
        if len(self.anno_in_image[self.image_id]) > 0:
            check = self.anno_id == self.anno_in_image[self.image_id][check_index]["id"]
 
        return check
    
    def check_modified_image(self):
        """
        현재 프레임이 수정된 상태인 확인하는 기능
        return (bool): 수정 유무            
        """
        ismod_image = True
        for anno in self.anno_in_image[self.image_id]:
            if anno["ismodify"] == 0:
                ismod_image = False
                break
        return ismod_image
 
    def check_same_track_id(self, track_id):
        """
        현재 프레임에 동일한 track_id 존재 유무 확인 기능(현재 선택된 객체는 제외하고 체크함)
        return (bool): 추적 아이디 존재 유무    
        """
        if self.anno_id is None:
            return False
        
        for idx, anno in enumerate(self.anno_in_image[self.image_id]):
            if idx == self.anno_idx_in_image:
                continue
            if anno['track_id'] == track_id:
                return True
        return False
 
    #===============================================#
 
 
    #===============get annotation data=============#
    def get_number_of_anno(self):
        """
        어노테이션(박스) 수량을 출력하는 기능
        return (int) : 어노테이션(박스) 수량
        """
        return len(self.anno_ids)
 
    def get_number_of_image(self):
        """
        이미지 수량을 출력하는 기능
        return (int) : 이미지 수량
        """
        return len(self.image_ids)
 
    def get_number_of_anno_in_image(self):
        """
        현재 프레임의 어노테이션(박스) 수량을 출력하는 기능
        return (int) : 현재 프레임의 어노테이션(박스) 수량
        """
        if self.image_id is None:
            return 0
        return len(self.anno_in_image[self.image_id])
 
    def get_anno_data_list(self):
        """
        현재 프레임의 모든 어노테이션(박스)정보를 출력하는 기능
        return:
            bbox_list (list[list]) : 박스위치 정보 리스트, [x, y, w, h]
            action_id_list (list[dict]) : 행동라벨 리스트
            track_id_list (list[int]) : 추적 아이디 리스트
            keypoints_list (list[np.array]) : 스켈레톤 좌표정보 리스트(x, y, score), shape (17, 3)
        """
        bbox_list = []
        action_id_list = []
        track_id_list = []
        keypoints_list = []
        if self.image_id is not None:
            for anno in self.anno_in_image[self.image_id]:
                np_key = np.array(anno["keypoints"])
 
                bbox_list.append(anno["bbox"])
                track_id_list.append(anno["track_id"])
                action_id_list.append(anno["action_id"])
                keypoints_list.append(np_key.reshape(17, 3))
        return bbox_list, action_id_list, track_id_list, keypoints_list
    
    def get_anno_data(self):
        """
        현재 선택된 어노테이션(박스) 정보를 출력하는 기능
        return (dict) : 어노테이션 정보(박스, 키포인트, 행동라벨 등)
        """
        if self.anno_idx is None:
            return None
        return copy.deepcopy(self.dataset['annotations'][self.anno_idx])
 
    def get_anno_data_in_image(self, image_idx=None, key = None, value = None, filter=False):
        """
        입력한 이미지 인덱스의 데이터에서 설정한 데이터에 부합하는 어노테이션 정보를 출력하는 기능        
        args:
            image_idx (int) : 검색하려는 이미지 인덱스, 설정하지 않는다면 현재 프레임이됨
            key (str) : 확인하려는 데이터의 키, 설정하지 않으면 필저링 조건만 체크함
            value : 확인하려는 데이터의 값
            filter (str) : 필터링 유무, 가려짐, 잘림 정도로 필터, Fasle로 설정하면 검색하려는 프레임의 모든 어노테이션 데이터를 반환함
        return (list[dict] or dict):
            필터링 조건을 통과한 어노테이션 리스트
            또는 조건에 부합하는 어노테이션
            조건에 부합하는 데이터가 없을경우 None을 반환함
        """
        if image_idx is None:
            image_id = self.image_id
        else:
            image_id = self.image_ids[image_idx]
            
        if key is None:
            if filter:
                ret_anno = []
                for anno in self.anno_in_image[image_id]:
                    if anno['occlusion'] > 2 or anno['truncation'] > 2:
                        continue
                    ret_anno.append(copy.deepcopy(anno))
                return ret_anno
            else:
                return copy.deepcopy(self.anno_in_image[image_id])
        
        for anno in self.anno_in_image[image_id]:
            if anno[key] == value:
                return copy.deepcopy(anno)
        return None
 
    def get_prev_anno_data(self, key, value):
        """
        설정되어 있는 프레임보다 이전 프레임에서 데이터를 검색하는 기능
        가장 가까운 프레임의 데이터를 반환함
        args:
            key (str): 확인하려는 데이터의 키
            value : 확인하려는 데이터의 값
        return (dict)):
            조건에 부합하는 데이터
            조건에 부합하는 데이터가 없을경우 None을 반환함
        """
        if value is None:
            return None
 
        for i in range(self.image_idx-1, -1, -1):
            for ann in self.anno_in_image[self.image_ids[i]]:
                if ann[key] == value:
                    return copy.deepcopy(ann)
        return None
 
    def get_track_info(self):
        """
        모든 추적 아이디에 대해서 추적 아이디가 처음 등장하는 프레임과 등장하는 프레임 수를 반환하는 기능
        return (dict): 추적 아이디의 정보
            key (int): 추적 아이디
            value (list): 첫번째 인자는 추적아이디가 등장하는 첫 프레임 인덱스, 두번째 인자는 추적아이디가 등장하는 프레임 수
        """
        track_info = {}
        for anno in self.dataset['annotations']:
            if anno['track_id'] in track_info:
                track_info[anno['track_id']][1] = track_info[anno['track_id']][1] + 1
            else:
                track_info[anno['track_id']] = [self.image_ids.index(anno['image_id']), 1]
        return track_info
    
    def get_track_anno_data(self, filter=False, start_frame=0, end_frame=None):
        """
        설정한 프레임 구간에서 모든 어노테이션의 추적 아이디 정보를 반환하는 기능
        args:
            filter (bool) : 필터링 유무, 가려짐, 잘림 정도로 필터
            start_frame (int) : 검색하려는 시작 프레임 인덱스
            end_frame (int) : 검색하려는 끝 프레임 인덱스(해당 인덱스를 포함하지 않음), 설정하지 않으면 맨 마지막 프레임까지 범위로 설정됨
        return (dict) : 추적 아이디를 기준으로 변환된 어노테이션 정보
            key (int): 추적 아이디
            value (list[dict]): 추적 아이디의 어노테이션 리스트
        """
        track_data = {}
 
        if end_frame == None:
            end_frame = len(self.image_ids)
 
        for anno in self.dataset['annotations']:
            if filter and (anno['occlusion'] > 2 or anno['truncation'] > 2):
                continue
 
            img_idx = self.image_ids.index(anno['image_id'])
            if img_idx < start_frame or img_idx >= end_frame:
                continue
 
            if anno['track_id'] in track_data:
                track_data[anno['track_id']].append(anno)
            else:
                track_data[anno['track_id']] = [anno]
                
        return track_data
    #===============================================#
 
    
    #=============annotation data change============#
    def set_annotation_data(self, anno):
        """
        현재 선택된 어노테이션 정보를 입력 데이터로 업데이트하는 기능
        args:
            anno (dict) : 업데이트 하려는 정보, anno에 포함된 키값의 데이터만 업데이트함
        """
        if self.anno_idx is not None:
            anno['ismodify'] = 1
            self.dataset['annotations'][self.anno_idx].update(anno)
            self.anno_in_image[self.image_id][self.anno_idx_in_image].update(anno)
 
    def insert_annotation_data(self):
        """
        더미 어노테이션을 추가하는 기능
        """
        tmp_anno_ids = [0]
        tmp_track_ids = [0]
        for ann in self.anno_in_image[self.image_id]:
            tmp_anno_ids.append(ann['id'])
            tmp_track_ids.append(ann['track_id'])
 
        new_anno_id = int(self.image_id*100 + max(tmp_anno_ids)%100+1)
        new_anno_idx = 0
        for i in range(self.image_idx+1):
            new_anno_idx = new_anno_idx + len(self.anno_in_image[self.image_ids[i]])
 
        anno = utils.make_dummy_annotation(new_anno_id, self.image_id, max(tmp_track_ids)+1)
        anno['ismodify'] = 1
        self.anno_in_image[self.image_id].append(copy.deepcopy(anno))
        self.anno_ids.insert(new_anno_idx, new_anno_id)
        self.dataset['annotations'].insert(new_anno_idx, copy.deepcopy(anno))
 
        self.anno_id = new_anno_id
        self.anno_idx = new_anno_idx
        self.anno_idx_in_image = len(self.anno_in_image[self.image_id])-1
 
    def insert_annotation_data_by_prev_anno(self, track_id):
        """
        입력한 추적 아이디의 어노테이션을 추가하는 기능
        이전 프레임에서 해당 추적 아이디 정보를 복사해서 추가함, 이전 프레임에 해당 추적 아이디가 없다면 더미 데이터를 추가함
        """
        tmp_anno_ids = [0]
        check_track_id = False
        for ann in self.anno_in_image[self.image_id]:
            tmp_anno_ids.append(ann['id'])
            if ann['track_id'] == track_id:
                check_track_id = True
 
        if check_track_id:
            return
 
        new_anno_id = int(self.image_id*100 + max(tmp_anno_ids)%100+1)
        new_anno_idx = 0
        for i in range(self.image_idx+1):
            new_anno_idx = new_anno_idx + len(self.anno_in_image[self.image_ids[i]])
 
        anno = self.get_prev_anno_data('track_id', track_id)
 
        if anno is None:
            anno = utils.make_dummy_annotation(new_anno_id, self.image_id, track_id)
        else:
            anno['id'] = new_anno_id
            anno['image_id'] = self.image_id
 
        anno['ismodify'] = 1
        self.anno_in_image[self.image_id].append(copy.deepcopy(anno))
        self.anno_ids.insert(new_anno_idx, new_anno_id)
        self.dataset['annotations'].insert(new_anno_idx, copy.deepcopy(anno))
 
        self.anno_id = new_anno_id
        self.anno_idx = new_anno_idx
        self.anno_idx_in_image = len(self.anno_in_image[self.image_id])-1
    
    def delete_annotation_data(self):
        """
        현재 선택된 어노테이션을 삭제하는 기능
        """
        del self.dataset['annotations'][self.anno_idx]
        del self.anno_in_image[self.image_id][self.anno_idx_in_image]
        del self.anno_ids[self.anno_idx]
 
        if self.get_number_of_anno_in_image() > 0:
            self.anno_idx_in_image = 0
            self.anno_id = self.anno_in_image[self.image_id][self.anno_idx_in_image]['id']
            self.anno_idx = self.anno_ids.index(self.anno_id)
        else:
            self.anno_id = None
            self.anno_idx = None
            self.anno_idx_in_image = None
 
    def update_annotation_data(self, key, data):
        """
        현재 선택된 어노테이션션 데이터를 업데이트하는 기능
        args:
            key : 업데이트하려는 데이터의 키
            data : 업데이트하려는 데이터
        """
        anno = {key:data}
        self.set_annotation_data(anno)
 
    def batch_update_annotation_data(self, key, value, new_anno, frame_range=None):
        """
        조건에 맞는 어노테이션을 모두 업데이트하는 기능
        프레임 범위를 설정할 수 있음
        args:
            key : 조건의 키
            value : 조건
            new_anno : 업데이트하려는 어노테이션 데이터
            frame_range : 업데이트하려는 프레임 범위, 범위를 설정하지 않는다면 전체 범위로 설정됨
        """
        start = 0
        end = self.get_number_of_image()
        
        new_anno['ismodify'] = 1
        if frame_range is not None:
            start = frame_range[0]
            end = frame_range[1]+1
        
        for image_idx in range(start, end):
            image_id = self.image_ids[image_idx]
            for idx_in_image, anno in enumerate(self.anno_in_image[image_id]):
                if anno[key] == value:
                    anno_id = anno['id']
                    anno_idx = self.anno_ids.index(anno_id)
                    self.dataset['annotations'][anno_idx].update(new_anno)
                    self.anno_in_image[image_id][idx_in_image].update(new_anno)
                    
    def update_annotation_data_by_anno_id(self, anno_id, key, data, anno=None):
        """
        입력한 어노테이션 아이디에 해당하는 정보를 업데이트하는 기능
        args:
            anno_id (int): 업데이트하려는 어노테이션 아이디
            key : 데이터의 키
            data : 업데이트하려는 데이터
            anno (dict)) : 업데이트하려는 데이터, 여러 데이터를 업데이트 하고싶을 때 사용
                anno를 설정하지 않을 경우 아이디에 해당하는 데이터의 key의 정보를 data로 업데이트함
        """
        if anno is None:
            new_anno = {key:data}
        else:
            new_anno = anno
            
        anno_idx = self.anno_ids.index(anno_id)
        image_id = self.dataset['annotations'][anno_idx]['image_id']
        anno_idx_in_image = self.get_anno_index_in_image(anno_id, image_id)
        
        self.dataset['annotations'][anno_idx].update(new_anno)
        self.anno_in_image[image_id][anno_idx_in_image].update(new_anno)
        
    #===============================================#
 
 
    #==================get anno index===============#
    def get_anno_index_in_image(self, anno_id, image_id):
        """
        설정한 프레임에서 특정 어노테이션 아이디의 인덱스를 반환하는 기능
        args:
            anno_id (int) : 검색하려는 어노테이션 아이디
            image_id (int) : 검색하려는 이미지 아이디
        return (int) : 어노테이션 인덱스
        """
        ret_idx = None
        for idx, anno in enumerate(self.anno_in_image[image_id]):
            if anno['id'] == anno_id:
                ret_idx = idx
        return ret_idx
    
    def get_anno_index(self, image_id, anno_idx_at_image):
        """
        설정한 프레임에 존재하는 어노테이션들 중 특정 인덱스(이미지 기준 변환 데이터)에 해당하는 어노테이션의 인덱스(원본 어노테이션 기준)를 반환하는 기능
        args:
            image_id (int): 검색하려는 이미지 아이디
            anno_idx_at_image (int): 해당 프레임에서의 이미지 인덱스
        return (int) : 어노테이션 인덱스
        """
        if len(self.anno_in_image[image_id]) <= anno_idx_at_image:
            return None
        
        anno_id = self.anno_in_image[image_id][anno_idx_at_image]['id']
        return self.anno_ids.index(anno_id)
    #===============================================#
 
 
    #===================read image==================#
    def get_image_folder(self):
        """
        어노테이션 정보에 대응하는 이미지가 저장되어있는 폴더를 반환하는 기능
        return (str): 이미지 폴더
        """
        return self.image_base_path
    
    def get_image_path(self, image_idx=None):
        """
        특정 이미지 경로를 반환하는 기능
        args:
            image_idx (int): 경로를 원하는 이미지의 인덱스, 설정하지 않는다면 현재 설정된 이미지의 경로를 반환함
        return (str): 이미지 경로
        """
        if image_idx is None:
            if self.image_idx is None:
                print('image_idx is None')
                return None
            
            image_idx = self.image_idx
            
        image_name = self.image_filenames[image_idx]
        
        return utils.join( [self.image_base_path, image_name] )
 
    def get_image_name(self, image_id=None):
        """
        특정 이미지의 이름을 반환하는 기능
        args:
            image_id (int) : 이름을 원하는 이미지의 아이디, 설정하지 않는다면 현재 설정된 이미지의 이름을 반환함
        return (str): 이미지 이름
        """
        if image_id is None:
            image_id = self.image_id
            
        if image_id is None:
            return None
        
        image_idx = self.image_ids.index(image_id)
        return self.image_filenames[image_idx]
 
    def read_image(self):
        """
        현재 설정된 이미지를 로드하는 기능
        return (np.array): RGB 이미지
        """
        if self.image_idx is None:
            return None
 
        image_path = self.get_image_path(image_idx=self.image_idx)
        
        if not os.path.exists(image_path):
            print(image_path)
            return None
        
        image = cv2.imread(image_path)
        return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    #===============================================#
    
    
    #===================read image==================#
    def get_save_path(self):
        """
        어노테이션 파일 저장 경로를 반환하는 기능
        """
        return self.save_path
    
    #===============================================#
 
 
    #===============get scenario num================#
    def get_scenario_number(self):
        if self.image_idx is None:
            return None
 
        if self.json_versionjson_version == 10:
            filename_re = re.compile('S\d{3}')
            scenario_num = filename_re.search(self.image_filenames[self.image_idx]).group()
        elif self.json_versionjson_version == 11:
            #수정필요
            scenario_num = "S001"
 
        return scenario_num
    #===============================================#