Public Member Functions
	__init__ (self, anno_path=None, save_path=None)

	init (self)

	load_annotation (self, anno_path, image_base=None, program_label_map_version=None, save_path=None)

	cvt_data_format (self, dataset)

	save_annotation (self)

	init_annotation (self)

	set_anno_idx_in_image (self, anno_idx_in_image)

	set_annotation_by_anno_index (self, anno_idx)

	set_annotation_by_image_index (self, image_idx, use_track_id=False)

	move_anno_right (self)

	move_anno_left (self)

	move_image_right (self, use_track_id=False)

	move_image_left (self, use_track_id=False)

	check_anno_pose_in_frame (self, check_index)

	check_modified_image (self)

	check_same_track_id (self, track_id)

	get_number_of_anno (self)

	get_number_of_image (self)

	get_number_of_anno_in_image (self)

	get_anno_data_list (self)

	get_anno_data (self)

	get_anno_data_in_image (self, image_idx=None, key=None, value=None, filter=False)

	get_prev_anno_data (self, key, value)

	get_track_info (self)

	get_track_anno_data (self, filter=False, start_frame=0, end_frame=None)

	set_annotation_data (self, anno)

	insert_annotation_data (self)

	insert_annotation_data_by_prev_anno (self, track_id)

	delete_annotation_data (self)

	update_annotation_data (self, key, data)

	batch_update_annotation_data (self, key, value, new_anno, frame_range=None)

	update_annotation_data_by_anno_id (self, anno_id, key, data, anno=None)

	get_anno_index_in_image (self, anno_id, image_id)

	get_anno_index (self, image_id, anno_idx_at_image)

	get_image_folder (self)

	get_image_path (self, image_idx=None)

	get_image_name (self, image_id=None)

	read_image (self)

	get_save_path (self)

	get_scenario_number (self)

Public Attributes
	json_version

	label_map_version

	save_path

Static Public Attributes
int	json_version = 10

	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

Detailed Description

세이프모션 행동 데이터를 관리하는 클래스
데이터 불러오기, 저장하기, 업데이트(데이터 변경), 프레임단위로 데이터 get, 추적 아이디 단위로 get 등의 기능 제공
args:
    anno_path (str) : 어노테이션 파일(json 파일) 경로
    save_path (str) : 저장 경로, 설정하지 않으면 anno_path에 저장됨

Definition at line 11 of file AnnotationDataManager.py.

Constructor & Destructor Documentation

◆ init()

AnnotationDataManager.AnnotationDataManager.__init__	(	self,
		anno_path = None,
		save_path = None )

Definition at line 35 of file AnnotationDataManager.py.

    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)
 

Member Function Documentation

◆ batch_update_annotation_data()

AnnotationDataManager.AnnotationDataManager.batch_update_annotation_data	(	self,
		key,
		value,
		new_anno,
		frame_range = None )

조건에 맞는 어노테이션을 모두 업데이트하는 기능
프레임 범위를 설정할 수 있음
args:
    key : 조건의 키
    value : 조건
    new_anno : 업데이트하려는 어노테이션 데이터
    frame_range : 업데이트하려는 프레임 범위, 범위를 설정하지 않는다면 전체 범위로 설정됨

Definition at line 580 of file AnnotationDataManager.py.

    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)
                    

◆ check_anno_pose_in_frame()

AnnotationDataManager.AnnotationDataManager.check_anno_pose_in_frame	(		self,
			check_index )

현재 프레임에서 현재 선택되어 있는 어노테이션(박스)이 처음인지 마지막인지 확인하는 기능
args:
    check_index (int) : 첫프레임 체크인지 마지막 프레임 체크인지 설정하는 파라미터
        0 : 첫프레임인지 확인
        -1 : 마지막 프레임인지 확인
return (bool): 확인 정보

Definition at line 276 of file AnnotationDataManager.py.

    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
    

◆ check_modified_image()

AnnotationDataManager.AnnotationDataManager.check_modified_image ( self )

현재 프레임이 수정된 상태인 확인하는 기능
return (bool): 수정 유무

Definition at line 291 of file AnnotationDataManager.py.

    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
 

◆ check_same_track_id()

AnnotationDataManager.AnnotationDataManager.check_same_track_id	(		self,
			track_id )

현재 프레임에 동일한 track_id 존재 유무 확인 기능(현재 선택된 객체는 제외하고 체크함)
return (bool): 추적 아이디 존재 유무

Definition at line 303 of file AnnotationDataManager.py.

    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
 

◆ cvt_data_format()

AnnotationDataManager.AnnotationDataManager.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): 이미지 이름 리스트

Definition at line 104 of file AnnotationDataManager.py.

    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
 

◆ delete_annotation_data()

AnnotationDataManager.AnnotationDataManager.delete_annotation_data ( self )

현재 선택된 어노테이션을 삭제하는 기능

Definition at line 553 of file AnnotationDataManager.py.

    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
 

◆ get_anno_data()

AnnotationDataManager.AnnotationDataManager.get_anno_data ( self )

현재 선택된 어노테이션(박스) 정보를 출력하는 기능
return (dict) : 어노테이션 정보(박스, 키포인트, 행동라벨 등)

Definition at line 368 of file AnnotationDataManager.py.

    def get_anno_data(self):
        """
        현재 선택된 어노테이션(박스) 정보를 출력하는 기능
        return (dict) : 어노테이션 정보(박스, 키포인트, 행동라벨 등)
        """
        if self.anno_idx is None:
            return None
        return copy.deepcopy(self.dataset['annotations'][self.anno_idx])
 

◆ get_anno_data_in_image()

AnnotationDataManager.AnnotationDataManager.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을 반환함

Definition at line 377 of file AnnotationDataManager.py.

    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
 

◆ get_anno_data_list()

AnnotationDataManager.AnnotationDataManager.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)

Definition at line 345 of file AnnotationDataManager.py.

    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
    

◆ get_anno_index()

AnnotationDataManager.AnnotationDataManager.get_anno_index	(	self,
		image_id,
		anno_idx_at_image )

설정한 프레임에 존재하는 어노테이션들 중 특정 인덱스(이미지 기준 변환 데이터)에 해당하는 어노테이션의 인덱스(원본 어노테이션 기준)를 반환하는 기능
args:
    image_id (int): 검색하려는 이미지 아이디
    anno_idx_at_image (int): 해당 프레임에서의 이미지 인덱스
return (int) : 어노테이션 인덱스

Definition at line 647 of file AnnotationDataManager.py.

    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)

◆ get_anno_index_in_image()

AnnotationDataManager.AnnotationDataManager.get_anno_index_in_image	(	self,
		anno_id,
		image_id )

설정한 프레임에서 특정 어노테이션 아이디의 인덱스를 반환하는 기능
args:
    anno_id (int) : 검색하려는 어노테이션 아이디
    image_id (int) : 검색하려는 이미지 아이디
return (int) : 어노테이션 인덱스

Definition at line 633 of file AnnotationDataManager.py.

    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
    

◆ get_image_folder()

AnnotationDataManager.AnnotationDataManager.get_image_folder ( self )

어노테이션 정보에 대응하는 이미지가 저장되어있는 폴더를 반환하는 기능
return (str): 이미지 폴더

Definition at line 664 of file AnnotationDataManager.py.

    def get_image_folder(self):
        """
        어노테이션 정보에 대응하는 이미지가 저장되어있는 폴더를 반환하는 기능
        return (str): 이미지 폴더
        """
        return self.image_base_path
    

◆ get_image_name()

AnnotationDataManager.AnnotationDataManager.get_image_name	(		self,
			image_id = None )

특정 이미지의 이름을 반환하는 기능
args:
    image_id (int) : 이름을 원하는 이미지의 아이디, 설정하지 않는다면 현재 설정된 이미지의 이름을 반환함
return (str): 이미지 이름

Definition at line 689 of file AnnotationDataManager.py.

    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]
 

◆ get_image_path()

AnnotationDataManager.AnnotationDataManager.get_image_path	(		self,
			image_idx = None )

특정 이미지 경로를 반환하는 기능
args:
    image_idx (int): 경로를 원하는 이미지의 인덱스, 설정하지 않는다면 현재 설정된 이미지의 경로를 반환함
return (str): 이미지 경로

Definition at line 671 of file AnnotationDataManager.py.

    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] )
 

◆ get_number_of_anno()

AnnotationDataManager.AnnotationDataManager.get_number_of_anno ( self )

어노테이션(박스) 수량을 출력하는 기능
return (int) : 어노테이션(박스) 수량

Definition at line 322 of file AnnotationDataManager.py.

    def get_number_of_anno(self):
        """
        어노테이션(박스) 수량을 출력하는 기능
        return (int) : 어노테이션(박스) 수량
        """
        return len(self.anno_ids)
 

◆ get_number_of_anno_in_image()

AnnotationDataManager.AnnotationDataManager.get_number_of_anno_in_image ( self )

현재 프레임의 어노테이션(박스) 수량을 출력하는 기능
return (int) : 현재 프레임의 어노테이션(박스) 수량

Definition at line 336 of file AnnotationDataManager.py.

    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])
 

◆ get_number_of_image()

AnnotationDataManager.AnnotationDataManager.get_number_of_image ( self )

이미지 수량을 출력하는 기능
return (int) : 이미지 수량

Definition at line 329 of file AnnotationDataManager.py.

    def get_number_of_image(self):
        """
        이미지 수량을 출력하는 기능
        return (int) : 이미지 수량
        """
        return len(self.image_ids)
 

◆ get_prev_anno_data()

AnnotationDataManager.AnnotationDataManager.get_prev_anno_data	(	self,
		key,
		value )

설정되어 있는 프레임보다 이전 프레임에서 데이터를 검색하는 기능
가장 가까운 프레임의 데이터를 반환함
args:
    key (str): 확인하려는 데이터의 키
    value : 확인하려는 데이터의 값
return (dict)):
    조건에 부합하는 데이터
    조건에 부합하는 데이터가 없을경우 None을 반환함

Definition at line 411 of file AnnotationDataManager.py.

    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
 

◆ get_save_path()

AnnotationDataManager.AnnotationDataManager.get_save_path ( self )

어노테이션 파일 저장 경로를 반환하는 기능

Definition at line 725 of file AnnotationDataManager.py.

    def get_save_path(self):
        """
        어노테이션 파일 저장 경로를 반환하는 기능
        """
        return self.save_path
    

◆ get_scenario_number()

AnnotationDataManager.AnnotationDataManager.get_scenario_number ( self )

Definition at line 735 of file AnnotationDataManager.py.

    def get_scenario_number(self):
        if self.image_idx is None:
            return None
 
        if self.json_version == 10:
            filename_re = re.compile('S\d{3}')
            scenario_num = filename_re.search(self.image_filenames[self.image_idx]).group()
        elif self.json_version == 11:
            #수정필요
            scenario_num = "S001"
 
        return scenario_num

◆ get_track_anno_data()

AnnotationDataManager.AnnotationDataManager.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]): 추적 아이디의 어노테이션 리스트

Definition at line 446 of file AnnotationDataManager.py.

    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

◆ get_track_info()

AnnotationDataManager.AnnotationDataManager.get_track_info ( self )

모든 추적 아이디에 대해서 추적 아이디가 처음 등장하는 프레임과 등장하는 프레임 수를 반환하는 기능
return (dict): 추적 아이디의 정보
    key (int): 추적 아이디
    value (list): 첫번째 인자는 추적아이디가 등장하는 첫 프레임 인덱스, 두번째 인자는 추적아이디가 등장하는 프레임 수

Definition at line 431 of file AnnotationDataManager.py.

    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
    

◆ init()

AnnotationDataManager.AnnotationDataManager.init ( self )

초기화 함수, 멤버변수 값을 초기화 함

Definition at line 40 of file AnnotationDataManager.py.

    def init(self):
        """
        초기화 함수, 멤버변수 값을 초기화 함
        """
 
        #파일 정보
        self.json_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 #현재 선택된 어노테이션(박스)의 아이디
        

◆ init_annotation()

AnnotationDataManager.AnnotationDataManager.init_annotation ( self )

현재 프레임 정보 초기화 기능
맨 첫프레임, 첫번째 어노테이션(박스) 정보로 셋팅함
첫프레임에 어노테이션 정보가 없다면 관련 변수는 None으로 셋팅됨

Definition at line 144 of file AnnotationDataManager.py.

    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']
 

◆ insert_annotation_data()

AnnotationDataManager.AnnotationDataManager.insert_annotation_data ( self )

더미 어노테이션을 추가하는 기능

Definition at line 491 of file AnnotationDataManager.py.

    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
 

◆ insert_annotation_data_by_prev_anno()

AnnotationDataManager.AnnotationDataManager.insert_annotation_data_by_prev_anno	(		self,
			track_id )

입력한 추적 아이디의 어노테이션을 추가하는 기능
이전 프레임에서 해당 추적 아이디 정보를 복사해서 추가함, 이전 프레임에 해당 추적 아이디가 없다면 더미 데이터를 추가함

Definition at line 516 of file AnnotationDataManager.py.

    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
    

◆ load_annotation()

AnnotationDataManager.AnnotationDataManager.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로 설정됨

Definition at line 66 of file AnnotationDataManager.py.

    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_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_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
 

◆ move_anno_left()

AnnotationDataManager.AnnotationDataManager.move_anno_left ( self )

이전 어노테이션(박스)로 이동함
return (bool): 이미지 변경 유무

Definition at line 244 of file AnnotationDataManager.py.

    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
 

◆ move_anno_right()

AnnotationDataManager.AnnotationDataManager.move_anno_right ( self )

다음 어노테이션(박스)로 이동함
return (bool): 이미지 변경 유무

Definition at line 231 of file AnnotationDataManager.py.

    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
 

◆ move_image_left()

AnnotationDataManager.AnnotationDataManager.move_image_left	(		self,
			use_track_id = False )

이전 이미지로 이동함

Definition at line 265 of file AnnotationDataManager.py.

    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)

◆ move_image_right()

AnnotationDataManager.AnnotationDataManager.move_image_right	(		self,
			use_track_id = False )

다음 이미지로 이동함

Definition at line 257 of file AnnotationDataManager.py.

    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)
 

◆ read_image()

AnnotationDataManager.AnnotationDataManager.read_image ( self )

현재 설정된 이미지를 로드하는 기능
return (np.array): RGB 이미지

Definition at line 705 of file AnnotationDataManager.py.

    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)

◆ save_annotation()

AnnotationDataManager.AnnotationDataManager.save_annotation ( self )

데이터 저장 기능

Definition at line 137 of file AnnotationDataManager.py.

    def save_annotation(self):
        """
        데이터 저장 기능
        """
        utils.save_json(self.save_path, self.dataset)
        

◆ set_anno_idx_in_image()

AnnotationDataManager.AnnotationDataManager.set_anno_idx_in_image	(		self,
			anno_idx_in_image )

현재 프레임의 어노테이션(박스) 인덱스 기준으로 관련 데이터를 셋팅함
args:
    anno_idx_in_image (int) : 설정하기 위한 현재 프레임의 어노테이션(박스) 인덱스

Definition at line 166 of file AnnotationDataManager.py.

    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)
 

◆ set_annotation_by_anno_index()

AnnotationDataManager.AnnotationDataManager.set_annotation_by_anno_index	(		self,
			anno_idx )

어노테이션(박스) 인덱스 기준으로 현재 정보를 셋팅함
args:
    anno_idx (int) : 셋팅하려는 어노테이션(박스) 인덱스
return (bool): 이미지 변경 유무

Definition at line 177 of file AnnotationDataManager.py.

    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
 

◆ set_annotation_by_image_index()

AnnotationDataManager.AnnotationDataManager.set_annotation_by_image_index	(	self,
		image_idx,
		use_track_id = False )

이미지 인덱스를 기준으로 현재 정보를 셋팅함
추적아이디 사용을 설정하면 현재 선택된 추적아이디와 같은 어노테이션 정보로 셋팅함
args:
    image_idx (int) : 셋팅하려는 이미지 인덱스
    use_track_id (bool) : 추적아이디 사용 여부
return (bool): 이미지 변경 유무

Definition at line 194 of file AnnotationDataManager.py.

    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
    

◆ set_annotation_data()

AnnotationDataManager.AnnotationDataManager.set_annotation_data	(		self,
			anno )

현재 선택된 어노테이션 정보를 입력 데이터로 업데이트하는 기능
args:
    anno (dict) : 업데이트 하려는 정보, anno에 포함된 키값의 데이터만 업데이트함

Definition at line 480 of file AnnotationDataManager.py.

    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)
 

◆ update_annotation_data()

AnnotationDataManager.AnnotationDataManager.update_annotation_data	(	self,
		key,
		data )

현재 선택된 어노테이션션 데이터를 업데이트하는 기능
args:
    key : 업데이트하려는 데이터의 키
    data : 업데이트하려는 데이터

Definition at line 570 of file AnnotationDataManager.py.

    def update_annotation_data(self, key, data):
        """
        현재 선택된 어노테이션션 데이터를 업데이트하는 기능
        args:
            key : 업데이트하려는 데이터의 키
            data : 업데이트하려는 데이터
        """
        anno = {key:data}
        self.set_annotation_data(anno)
 

◆ update_annotation_data_by_anno_id()

AnnotationDataManager.AnnotationDataManager.update_annotation_data_by_anno_id	(	self,
		anno_id,
		key,
		data,
		anno = None )

입력한 어노테이션 아이디에 해당하는 정보를 업데이트하는 기능
args:
    anno_id (int): 업데이트하려는 어노테이션 아이디
    key : 데이터의 키
    data : 업데이트하려는 데이터
    anno (dict)) : 업데이트하려는 데이터, 여러 데이터를 업데이트 하고싶을 때 사용
        anno를 설정하지 않을 경우 아이디에 해당하는 데이터의 key의 정보를 data로 업데이트함

Definition at line 607 of file AnnotationDataManager.py.

    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)
        

Member Data Documentation

◆ anno_id

AnnotationDataManager.AnnotationDataManager.anno_id = None

static

Definition at line 32 of file AnnotationDataManager.py.

◆ anno_ids

AnnotationDataManager.AnnotationDataManager.anno_ids = None

static

Definition at line 25 of file AnnotationDataManager.py.

◆ anno_idx

AnnotationDataManager.AnnotationDataManager.anno_idx = None

static

Definition at line 31 of file AnnotationDataManager.py.

◆ anno_idx_in_image

AnnotationDataManager.AnnotationDataManager.anno_idx_in_image = None

static

Definition at line 33 of file AnnotationDataManager.py.

◆ anno_in_image

AnnotationDataManager.AnnotationDataManager.anno_in_image = None

static

Definition at line 24 of file AnnotationDataManager.py.

◆ anno_path

AnnotationDataManager.AnnotationDataManager.anno_path = None

static

Definition at line 20 of file AnnotationDataManager.py.

◆ base_path

AnnotationDataManager.AnnotationDataManager.base_path = None

static

Definition at line 22 of file AnnotationDataManager.py.

◆ dataset

AnnotationDataManager.AnnotationDataManager.dataset = None

static

Definition at line 23 of file AnnotationDataManager.py.

◆ image_base_path

AnnotationDataManager.AnnotationDataManager.image_base_path = None

static

Definition at line 21 of file AnnotationDataManager.py.

◆ image_filenames

AnnotationDataManager.AnnotationDataManager.image_filenames = None

static

Definition at line 27 of file AnnotationDataManager.py.

◆ image_id

AnnotationDataManager.AnnotationDataManager.image_id = None

static

Definition at line 30 of file AnnotationDataManager.py.

◆ image_ids

AnnotationDataManager.AnnotationDataManager.image_ids = None

static

Definition at line 26 of file AnnotationDataManager.py.

◆ image_idx

AnnotationDataManager.AnnotationDataManager.image_idx = None

static

Definition at line 29 of file AnnotationDataManager.py.

◆ json_version [1/2]

int AnnotationDataManager.AnnotationDataManager.json_version = 10

static

Definition at line 19 of file AnnotationDataManager.py.

◆ json_version [2/2]

AnnotationDataManager.AnnotationDataManager.json_version

Definition at line 46 of file AnnotationDataManager.py.

◆ label_map_version

AnnotationDataManager.AnnotationDataManager.label_map_version

Definition at line 47 of file AnnotationDataManager.py.

◆ save_path

AnnotationDataManager.AnnotationDataManager.save_path

Definition at line 49 of file AnnotationDataManager.py.

The documentation for this class was generated from the following file:

smdataset/AnnotationDataManager.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ batch_update_annotation_data()

◆ check_anno_pose_in_frame()

◆ check_modified_image()

◆ check_same_track_id()

◆ cvt_data_format()

◆ delete_annotation_data()

◆ get_anno_data()

◆ get_anno_data_in_image()

◆ get_anno_data_list()

◆ get_anno_index()

◆ get_anno_index_in_image()

◆ get_image_folder()

◆ get_image_name()

◆ get_image_path()

◆ get_number_of_anno()

◆ get_number_of_anno_in_image()

◆ get_number_of_image()

◆ get_prev_anno_data()

◆ get_save_path()

◆ get_scenario_number()

◆ get_track_anno_data()

◆ get_track_info()

◆ init()

◆ init_annotation()

◆ insert_annotation_data()

◆ insert_annotation_data_by_prev_anno()

◆ load_annotation()

◆ move_anno_left()

◆ move_anno_right()

◆ move_image_left()

◆ move_image_right()

◆ read_image()

◆ save_annotation()

◆ set_anno_idx_in_image()

◆ set_annotation_by_anno_index()

◆ set_annotation_by_image_index()

◆ set_annotation_data()

◆ update_annotation_data()

◆ update_annotation_data_by_anno_id()

Member Data Documentation

◆ anno_id

◆ anno_ids

◆ anno_idx

◆ anno_idx_in_image

◆ anno_in_image

◆ anno_path

◆ base_path

◆ dataset

◆ image_base_path

◆ image_filenames

◆ image_id

◆ image_ids

◆ image_idx

◆ json_version [1/2]

◆ json_version [2/2]

◆ label_map_version

◆ save_path

◆ init()