def coco_eval(result_files, result_types, coco, max_dets=(100, 300, 1000)): for res_type in result_types: assert res_type in [ 'proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints' ] if mmcv.is_str(coco): coco = COCO(coco) assert isinstance(coco, COCO) if result_types == ['proposal_fast']: ar = fast_eval_recall(result_files, coco, np.array(max_dets)) for i, num in enumerate(max_dets): print('AR@{}\t= {:.4f}'.format(num, ar[i])) return for res_type in result_types: result_file = result_files[res_type] # assert result_file.endswith('.json') coco_dets = coco.loadRes(result_file) img_ids = coco.getImgIds() iou_type = 'bbox' if res_type == 'proposal' else res_type cocoEval = COCOeval(coco, coco_dets, iou_type) cocoEval.params.imgIds = img_ids if res_type == 'proposal': cocoEval.params.useCats = 0 cocoEval.params.maxDets = list(max_dets) cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize()
def coco_process(): """ Process COCO Images """ # Define COCO Data to Gather dataType = args.dataset + '2017' annFile = '{}/annotations/person_keypoints_{}.json'.format( args.dataDir, dataType) # Remove Current h5 File from Output if os.path.exists(args.output): os.remove(args.output) # initialize COCO api for person keypoints annotations coco = COCO(annFile) # get all images containing given categories, select one at random catIds = coco.getCatIds(catNms=['person']) imgIds = coco.getImgIds(catIds=catIds) # Joint names with open(annFile) as f: json_data = json.load(f) keypoint_names = json_data['categories'][0]['keypoints'] # Open h5 File h5f = h5py.File(args.output, 'a') start_time = time.time() # for all iterations for count in range(min(args.cnt, len(imgIds))): # load image + keypoints I, img = load(annFile, coco, imgIds, dataType, count) # load annotations annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None) anns = coco.loadAnns(annIds) # Create Dataframe df = keypoints_df(anns) # If Img has any Keypoints if df is not None: # Scale Img and Keypoints im_scaled, df_scaled = scale(I, df) # Write to h5 h5_write(img, h5f, df_scaled, im_scaled) # If testing, test all and exit if args.testing == True: h5f.close() coco_test_img(df, df_scaled, im_scaled, I, coco, anns) h5_attributes(keypoint_names) coco_test_h5() exit() else: # Disregard image with no keypoints pass if count % 100 == 0: print('{} Samples Done - {} Taken'.format( count, (str(datetime.timedelta(seconds=(time.time() - start_time)))))) return keypoint_names
class CocoDataset(CustomDataset): CLASSES = ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic_light', 'fire_hydrant', 'stop_sign', 'parking_meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports_ball', 'kite', 'baseball_bat', 'baseball_glove', 'skateboard', 'surfboard', 'tennis_racket', 'bottle', 'wine_glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot_dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted_plant', 'bed', 'dining_table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy_bear', 'hair_drier', 'toothbrush') def load_annotations(self, ann_file): self.coco = COCO(ann_file) self.cat_ids = self.coco.getCatIds() self.cat2label = { cat_id: i + 1 for i, cat_id in enumerate(self.cat_ids) } self.img_ids = self.coco.getImgIds() img_infos = [] for i in self.img_ids: info = self.coco.loadImgs([i])[0] info['filename'] = info['file_name'] img_infos.append(info) return img_infos def get_ann_info(self, idx): img_id = self.img_infos[idx]['id'] ann_ids = self.coco.getAnnIds(imgIds=[img_id]) ann_info = self.coco.loadAnns(ann_ids) return self._parse_ann_info(ann_info, self.with_mask) def _filter_imgs(self, min_size=32): """Filter images too small or without ground truths.""" valid_inds = [] ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values()) for i, img_info in enumerate(self.img_infos): if self.img_ids[i] not in ids_with_ann: continue if min(img_info['width'], img_info['height']) >= min_size: valid_inds.append(i) return valid_inds def _parse_ann_info(self, ann_info, with_mask=True): """Parse bbox and mask annotation. Args: ann_info (list[dict]): Annotation info of an image. with_mask (bool): Whether to parse mask annotations. Returns: dict: A dict containing the following keys: bboxes, bboxes_ignore, labels, masks, mask_polys, poly_lens. """ gt_bboxes = [] gt_labels = [] gt_bboxes_ignore = [] # Two formats are provided. # 1. mask: a binary map of the same size of the image. # 2. polys: each mask consists of one or several polys, each poly is a # list of float. if with_mask: gt_masks = [] gt_mask_polys = [] gt_poly_lens = [] for i, ann in enumerate(ann_info): if ann.get('ignore', False): continue x1, y1, w, h = ann['bbox'] if ann['area'] <= 0 or w < 1 or h < 1: continue bbox = [x1, y1, x1 + w - 1, y1 + h - 1] if ann['iscrowd']: gt_bboxes_ignore.append(bbox) else: gt_bboxes.append(bbox) gt_labels.append(self.cat2label[ann['category_id']]) if with_mask: gt_masks.append(self.coco.annToMask(ann)) mask_polys = [ p for p in ann['segmentation'] if len(p) >= 6 ] # valid polygons have >= 3 points (6 coordinates) poly_lens = [len(p) for p in mask_polys] gt_mask_polys.append(mask_polys) gt_poly_lens.extend(poly_lens) if gt_bboxes: gt_bboxes = np.array(gt_bboxes, dtype=np.float32) gt_labels = np.array(gt_labels, dtype=np.int64) else: gt_bboxes = np.zeros((0, 4), dtype=np.float32) gt_labels = np.array([], dtype=np.int64) if gt_bboxes_ignore: gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32) else: gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32) ann = dict( bboxes=gt_bboxes, labels=gt_labels, bboxes_ignore=gt_bboxes_ignore) if with_mask: ann['masks'] = gt_masks # poly format is not used in the current implementation ann['mask_polys'] = gt_mask_polys ann['poly_lens'] = gt_poly_lens return ann
""" Created on Sat Feb 22 16:58:58 2020 @author: zhangyiqian """ from cocoapi.PythonAPI.pycocotools.coco import COCO import numpy as np from skimage.io import imread, imshow, imsave import matplotlib.pyplot as plt from skimage import draw import random import cv2 as cv import time annFile = '/home/yiqian/Documents/dataset/COCO/annotations_valstuff/stuff_val2017.json' coco = COCO(annFile) imgIds = coco.getImgIds() img = coco.loadImgs(imgIds[0])[0] I = imread(img['coco_url']) plt.figure() imshow(I) # catIds = coco.getCatIds(catNms=['person']); annIds = coco.getAnnIds(imgIds=img['id'], catIds=coco.getCatIds(), iscrowd=False) # annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=False) anns = coco.loadAnns(annIds) coco.showAnns(anns) # sample scribble areas based on uniform distribution # sample_area_num = np.random.randint(1, len(anns)+1)
def read_data(data_dir, image_size, pixels_per_grid=32, no_label=False): """ Load the data and preprocessing for YOLO detector :param data_dir: str, path to the directory to read. It should include class_map, anchors, annotations :image_size: tuple, image size for resizing images :pixels_per_gird: int, the actual size of a grid :no_label: bool, whetehr to load labels :return: X_set: np.ndarray, shape: (N, H, W, C). y_set: np.ndarray, shape: (N, g_H, g_W, anchors, 5 + num_classes). """ im_dir = os.path.join(data_dir, 'val2017') class_map_path = '/home/intern/data/coco/classes_coco.json' # class_map_path = os.path.join(data_dir, 'classes.json') #anchors_path = os.path.join(data_dir, 'anchors.json') class_map = load_json(class_map_path) anchors = load_json('/home/intern/data/face/train/anchors.json') #anchors = load_json(anchors_path) num_classes = len(class_map) grid_h, grid_w = [image_size[i] // pixels_per_grid for i in range(2)] im_paths = [] for ext in IM_EXTENSIONS: im_paths.extend(glob.glob(os.path.join(im_dir, '*.{}'.format(ext)))) #anno_dir = os.path.join(data_dir, 'annotations') images = [] labels = [] ########################################################################### dataDir='/home/intern/data/coco' dataType='val2017' annFile='{}/annotations/instances_{}.json'.format(dataDir,dataType) coco=COCO(annFile) all_file_name = coco.getImgIds()#int type ########################################################################### for im_path in im_paths: # load image and resize image im = imread(im_path) #print(im_path) im = np.array(im, dtype=np.float32) im_origina_sizes = im.shape[:2] im = resize(im, (image_size[1], image_size[0])) if len(im.shape) == 2: im = np.expand_dims(im, 2) im = np.concatenate([im, im, im], -1) images.append(im) if no_label: labels.append(0) continue # load bboxes and reshape for yolo model name = os.path.splitext(os.path.basename(im_path))[0] ########################################################################### name_nonzero_int = int(name.lstrip('0'))#str type -> int(remove '0') real_anno = {} annos_one_img = coco.getAnnIds(imgIds=[name_nonzero_int])#annotations one img for i in range(0,len(annos_one_img)): anno_contents = coco.loadAnns(ids=[annos_one_img[i]])#info of one anno->type: [{}] anno_contents[0]['category_id'] category_name = coco.loadCats(ids=[anno_contents[0]['category_id']])[0]['name']#name bbbox = anno_contents[0]['bbox']#bbox [x,y,w,h] trans_bbbox = [bbbox[0], bbbox[1], bbbox[0]+bbbox[2], bbbox[1]+bbbox[3]]#[x_min,y_min,x_max,y_max] if category_name in real_anno: real_anno[category_name].append(trans_bbbox) else: real_anno[category_name] = [trans_bbbox] ########################################################################### #anno_path = os.path.join(anno_dir, '{}.anno'.format(name)) #anno = load_json(anno_path) anno = real_anno #print(anno) label = np.zeros((grid_h, grid_w, len(anchors), 5 + num_classes)) for c_idx, c_name in class_map.items(): if c_name not in anno: continue #print(anno[c_name]) for x_min, y_min, x_max, y_max in anno[c_name]: oh, ow = im_origina_sizes # normalize object coordinates and clip the values x_min, y_min, x_max, y_max = x_min / ow, y_min / oh, x_max / ow, y_max / oh x_min, y_min, x_max, y_max = np.clip([x_min, y_min, x_max, y_max], 0, 1) # assign the values to the best anchor anchor_boxes = np.array(anchors) / np.array([ow, oh]) best_anchor = get_best_anchor( anchor_boxes, [x_max - x_min, y_max - y_min]) cx = int(np.floor(0.5 * (x_min + x_max) * grid_w)) cy = int(np.floor(0.5 * (y_min + y_max) * grid_h)) label[cy, cx, best_anchor, 0:4] = [x_min, y_min, x_max, y_max] label[cy, cx, best_anchor, 4] = 1.0 label[cy, cx, best_anchor, 5 + int(c_idx)] = 1.0 labels.append(label) X_set = np.array(images, dtype=np.float32) y_set = np.array(labels, dtype=np.float32) return X_set, y_set