def get_coco_dicts(data_dir): if 'train' in data_dir: file_path = '/media/tangyp/Data/coco/train2014' elif 'val' in data_dir: file_path = '/media/tangyp/Data/coco/val2014' json_file = data_dir coco = COCO(json_file) catIds = coco.getCatIds(catNms=['person']) imgIds = coco.getImgIds(catIds=catIds) imgs = coco.loadImgs(imgIds) dataset_dicts = [] for img in imgs: dataset_dict = {} new_img = {'file_name': os.path.join(file_path, img['file_name']), 'height': img['height'], 'width': img['width'], 'image_id': img['id']} annId = coco.getAnnIds(imgIds=img['id']) anns = coco.loadAnns(ids=annId) annotation = {} annotation['annotations'] = [] for ann in anns: new_ann = {'iscrowd': ann['iscrowd'], 'bbox': ann['bbox'], 'category_id': ann['category_id'], 'segmentation': ann['segmentation'], 'bbox_mode': BoxMode(1)} annotation['annotations'].append(new_ann) dataset_dict.update(new_img) dataset_dict.update(annotation) dataset_dicts.append(dataset_dict) return dataset_dicts
def show_json_angle(): """ according json file to visualization :return: """ img_path = '/Dataset/DOTA_TEST/images/' json_path = '/Dataset/DOTA_TEST/DOTA_DOTA_TEST_angle.json' save_path = '/Dataset/DOTA_TEST/show/' import pycocotools.coco as coco coco = coco.COCO(json_path) images = coco.getImgIds() image_num = len(os.listdir(img_path)) for idx in range(image_num): img_id = images[idx] file_name = coco.loadImgs(ids=[img_id])[0]['file_name'] pics_path = os.path.join(img_path, file_name) ann_ids = coco.getAnnIds(imgIds=[img_id]) anns = coco.loadAnns(ids=ann_ids) num_objs = len(anns) img = cv2.imread(pics_path) for k in range(num_objs): bbox = np.array(anns[k]['bbox']) # print((bbox[0], bbox[1]), (bbox[2], bbox[3]), bbox[4]/math.pi*180) bbox8 = cv2.boxPoints(((bbox[0], bbox[1]), (bbox[2], bbox[3]), bbox[4] / math.pi * 180)) # cat = cate[count] img = add_bbox(img, bbox8, anns[k]['category_id']) cv2.imwrite(save_path + file_name, img) print('\r{}/{}'.format(idx, image_num), end='')
def main(): print("\nDATA:{}\nOUT_TYPE:{}\n".format(DATA, OUT_TYPE)) dets = [] img_ids = coco.getImgIds() num_images = len(img_ids) # ipdb.set_trace() for i, img_id in enumerate(img_ids): if i % 10 == 0: print("{}/{}".format(i, len(img_ids)), end="\r") # ipdb.set_trace() if DEBUG_ and i > DEBUG_: break img_info = coco.loadImgs(ids=[img_id])[0] if DATA == "lvis": img_name = img_info['file_name'] elif DATA == "coco": img_name = "COCO_val2014_" + img_info['file_name'] img_path = IMG_PATH + img_name img = cv2.imread(img_path) gt_ids = coco.getAnnIds(imgIds=[img_id]) gts = coco.loadAnns(gt_ids) gt_img = img.copy() for j, pred in enumerate(gts): bbox = _coco_box_to_bbox(pred['bbox']) gt_img = add_box(gt_img, bbox, 1.00) img_name = '{}_{}.jpg'.format(str(img_id).zfill(12), OUT_NAME_SUFFIX) cv2.imwrite(os.path.join(OUT_PATH, img_name), gt_img)
def main(): dets = [] # Get img_ids from lvis, instead. img_ids = coco.getImgIds() num_images = len(img_ids) # import pdb; pdb.set_trace() prog_bar = mmcv.ProgressBar(len(img_ids)) for i, img_id in enumerate(img_ids): # ipdb.set_trace() if DEBUG_ is True: if i > 100: break img_info = coco.loadImgs(ids=[img_id])[0] img_path = IMG_PATH + img_info['file_name'] img = cv2.imread(img_path) gt_ids = coco.getAnnIds(imgIds=[img_id]) gts = coco.loadAnns(gt_ids) gt_img = img.copy() for j, pred in enumerate(gts): bbox = _coco_box_to_bbox(pred['bbox']) cat_id = pred['category_id'] gt_img = add_box(gt_img, bbox, 1.00, cat_id) img_name = '{}_gt.jpg'.format(str(img_id).zfill(12)) cv2.imwrite(os.path.join(OUT_PATH, img_name), gt_img) prog_bar.update()
def get_custom_dicts(data_dir): if 'train' in data_dir: file_path = '/media/tangyp/Data/coco/train2014' elif 'val' in data_dir: file_path = '/media/tangyp/Data/coco/val2014' json_file = data_dir coco = COCO(json_file) with open(json_file) as f: imgs_anns = json.load(f) dataset_dicts = [] imgs = imgs_anns['images'] for img in imgs: dataset_dict = {} # new_img = {'file_name': '/media/tangyp/Data/coco/train2014' + '/' + img['file_name'], 'height': img['height'], 'width': img['width'], # 'image_id': img['id']} new_img = {'file_name': os.path.join(file_path, img['file_name']), 'height': img['height'], 'width': img['width'], 'image_id': img['id']} annId = coco.getAnnIds(imgIds=img['id']) anns = coco.loadAnns(ids=annId) annotation = {} annotation['annotations'] = [] for ann in anns: new_ann = {'iscrowd': ann['iscrowd'], 'bbox': ann['bbox'], 'category_id': ann['category_id'], 'segmentation': ann['segmentation'], 'bbox_mode': BoxMode(1)} annotation['annotations'].append(new_ann) dataset_dict.update(new_img) dataset_dict.update(annotation) dataset_dicts.append(dataset_dict) debug = 1 return dataset_dicts
def iter_images(category_name, parameters, _filter, image_callback=None): """ :param category_name: COCO category name. :param parameters: Dict with keys: parameters = { 'coco-data-dir': pathlib.Path('/data/datasets/coco2017/'), 'annotations': pathlib.Path('annotations/person_keypoints_train2017.json'), 'train-images': pathlib.Path('train/images'), 'results-dir': pathlib.Path('results') } :param _filter: Callable with _filter(image_path, annotations, min_size, rescale). :param image_callback: If not None, is called for each image with arguments image_callback(image_name, image_path, results_dir, annotations) """ coco = pycocotools.coco.COCO( str(parameters['coco-data-dir'] / parameters['annotations'])) category_id, image_ids = get_category_info([category_name], coco)[category_name] results_dir = parameters['results-dir'] / category_name results_dir.mkdir(parents=True, exist_ok=True) num_crops = 0 plot_images = [] for i, image_id in enumerate(image_ids): image_info = coco.loadImgs(image_id)[0] annotations = coco.loadAnns( coco.getAnnIds(imgIds=image_id, catIds=category_id, iscrowd=0)) image_path = parameters['coco-data-dir'] / parameters[ 'train-images'] / (image_info['file_name']) image_name = f'{category_name}-{image_id}-{i}' if image_callback: image_callback(image_name, image_path, results_dir, annotations) for j, (cropped, cropped_original_bg) in enumerate( _filter(image_path, annotations, parameters['min-size'], parameters['rescale'])): num_crops += 1 crop_name = image_name + f'-{j}' cropped.save(results_dir / str(crop_name + '.png')) cropped_original_bg.save(results_dir / str(crop_name + '-bg.png')) if len(plot_images) < 36: plot_images.append(np.array(cropped)) plot_images.append(np.array(cropped_original_bg)) if len(plot_images) == 36: plot.grid(np.array(plot_images), 6, 6, results_dir / 'examples.pdf') return num_crops
def _load_image_anns(self, img_id, coco, img_dir): img_info = coco.loadImgs(ids=[img_id])[0] file_name = img_info['file_name'] img_path = os.path.join(img_dir, file_name) ann_ids = coco.getAnnIds(imgIds=[img_id]) anns = copy.deepcopy(coco.loadAnns(ids=ann_ids)) img = cv2.imread(img_path) return img, anns, img_info, img_path
def main(): img_seq = [] # Get img_ids from lvis, instead. img_ids = coco.getImgIds() num_images = len(img_ids) # import ipdb; ipdb.set_trace() dets = [] dets.append(coco.loadRes(PRE_PATH)) prog_bar = mmcv.ProgressBar(len(img_ids)) for i, img_id in enumerate(img_ids): # ipdb.set_trace() if DEBUG_ is True: if i == DEBUG_FRAMES: break img_info = coco.loadImgs(ids=[img_id])[0] img_path = IMG_PATH + img_info['file_name'] img = cv2.imread(img_path) # Create a gt labeled img. gt_ids = coco.getAnnIds(imgIds=[img_id]) gts = coco.loadAnns(gt_ids) gt_img = img for j, pred in enumerate(gts): bbox = _coco_box_to_bbox(pred['bbox']) cat_id = pred['category_id'] gt_img = add_box(gt_img, bbox, 1.00, cat_id) gt_img = add_to_canvas(gt_img) # Create a predictions labeled img. for k in range(len(dets)): pred_ids = dets[k].getAnnIds(imgIds=[img_id]) preds = dets[k].loadAnns(pred_ids) pred_img = img.copy() for j, pred in enumerate(preds): bbox = _coco_box_to_bbox(pred['bbox']) sc = pred['score'] cat_id = pred['category_id'] if sc > VIS_THR: pred_img = add_box(pred_img, bbox, sc, cat_id) # ipdb.set_trace() pred_img = add_to_canvas(pred_img) # Create a super image and save it. sup_img = np.concatenate((gt_img, pred_img), axis=1) sup_img_name = 'pre_{}.jpg'.format(str(img_id).zfill(12)) cv2.imwrite(os.path.join(OUT_PATH, sup_img_name), sup_img) img_seq.append(sup_img) prog_bar.update()
def coco(writer, name_index, profile, row, verify=False): root = os.path.expanduser(os.path.expandvars(row['root'])) year = str(row['year']) name = profile + year path = os.path.join(root, 'annotations', 'instances_%s.json' % name) if not os.path.exists(path): tf.logging.warn(path + ' not exists') return False import pycocotools.coco coco = pycocotools.coco.COCO(path) catIds = coco.getCatIds(catNms=list(name_index.keys())) cats = coco.loadCats(catIds) id_index = dict((cat['id'], name_index[cat['name']]) for cat in cats) imgIds = coco.getImgIds() path = os.path.join(root, name) imgs = coco.loadImgs(imgIds) _imgs = list(filter(lambda img: os.path.exists(os.path.join(path, img['file_name'])), imgs)) if len(imgs) > len(_imgs): tf.logging.warn('%d of %d images not exists' % (len(imgs) - len(_imgs), len(imgs))) cnt_noobj = 0 for img in tqdm.tqdm(_imgs): annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None) anns = coco.loadAnns(annIds) if len(anns) <= 0: cnt_noobj += 1 continue imagepath = os.path.join(path, img['file_name']) width, height = img['width'], img['height'] imageshape = [height, width, 3] objects_class = np.array([id_index[ann['category_id']] for ann in anns], dtype=np.int64) objects_coord = [ann['bbox'] for ann in anns] objects_coord = [(x, y, x + w, y + h) for x, y, w, h in objects_coord] objects_coord = np.array(objects_coord, dtype=np.float32) if verify: if not verify_coords(objects_coord, imageshape): tf.logging.error('failed to verify coordinates of ' + imagepath) continue if not verify_image_jpeg(imagepath, imageshape): tf.logging.error('failed to decode ' + imagepath) continue assert len(objects_class) == len(objects_coord) example = tf.train.Example(features=tf.train.Features(feature={ 'imagepath': tf.train.Feature(bytes_list=tf.train.BytesList(value=[tf.compat.as_bytes(imagepath)])), 'imageshape': tf.train.Feature(int64_list=tf.train.Int64List(value=imageshape)), 'objects': tf.train.Feature(bytes_list=tf.train.BytesList(value=[objects_class.tostring(), objects_coord.tostring()])), })) writer.write(example.SerializeToString()) if cnt_noobj > 0: tf.logging.warn('%d of %d images have no object' % (cnt_noobj, len(_imgs))) return True
def load_ss_data(coco_dir, data_name, cache_dir, input_size=None): """セマンティックセグメンテーションのデータの読み込み。""" from pycocotools import coco, mask as cocomask coco_dir = pathlib.Path(coco_dir) cache_dir = pathlib.Path(cache_dir) if isinstance(input_size, int): input_size = (input_size, input_size) coco = coco.COCO( str(coco_dir / "annotations" / f"instances_{data_name}.json")) class_names = [c["name"] for c in coco.loadCats(coco.getCatIds())] jsonclassid_to_index = { c["id"]: class_names.index(c["name"]) for c in coco.loadCats(coco.getCatIds()) } X, y = [], [] for entry in utils.tqdm(coco.loadImgs(coco.getImgIds()), desc="load_ss_data"): dirname, filename = entry["coco_url"].split("/")[-2:] save_path = cache_dir / dirname / (filename + ".npy") X.append(coco_dir / dirname / filename) y.append(save_path) if not save_path.exists(): # 読み込み objs = coco.loadAnns( coco.getAnnIds(imgIds=entry["id"], iscrowd=None)) mask = np.zeros( (entry["height"], entry["width"], len(class_names)), dtype=np.uint8) for obj in objs: if obj.get("ignore", 0) == 1: continue rle = cocomask.frPyObjects(obj["segmentation"], entry["height"], entry["width"]) m = cocomask.decode(rle) class_id = jsonclassid_to_index[obj["category_id"]] mask[:, :, class_id] |= m mask = np.where(mask, np.uint8(255), np.uint8(0)) # リサイズ if input_size is not None: mask = ndimage.resize(mask, input_size[1], input_size[0]) # 保存 save_path.parent.mkdir(parents=True, exist_ok=True) np.save(str(save_path), mask) return np.array(X), np.array(y), class_names
def load_od_data(coco_dir, data_name, use_crowded): """物体検出のデータの読み込み。""" import pycocotools.coco coco_dir = pathlib.Path(coco_dir) coco = pycocotools.coco.COCO( str(coco_dir / "annotations" / f"instances_{data_name}.json")) class_names = [c["name"] for c in coco.loadCats(coco.getCatIds())] jsonclassid_to_index = { c["id"]: class_names.index(c["name"]) for c in coco.loadCats(coco.getCatIds()) } labels = [] for entry in coco.loadImgs(coco.getImgIds()): dirname, filename = entry["coco_url"].split("/")[-2:] objs = coco.loadAnns( coco.getAnnIds(imgIds=entry["id"], iscrowd=None if use_crowded else False)) bboxes, classes, areas, crowdeds = [], [], [], [] width, height = entry["width"], entry["height"] for obj in objs: if obj.get("ignore", 0) == 1: continue x, y, w, h = obj["bbox"] bbox = np.array([x, y, x + w, y + h]) / np.array( [width, height, width, height]) bbox = np.clip(bbox, 0, 1) if (bbox[:2] < bbox[2:]).all(): bboxes.append(bbox) classes.append(jsonclassid_to_index[obj["category_id"]]) areas.append(obj["area"]) crowdeds.append(obj["iscrowd"]) labels.append( tk.od.ObjectsAnnotation( path=coco_dir / dirname / filename, width=width, height=height, classes=classes, bboxes=bboxes, areas=areas, crowdeds=crowdeds, )) return tk.od.ObjectsAnnotation.create_dataset(labels, class_names=class_names)
def _load_image_anns(self, img_id, coco, img_dir): img_info = coco.loadImgs(ids=[img_id])[0] file_name = img_info['file_name'] img_path = os.path.join(img_dir, file_name) ann_ids = coco.getAnnIds(imgIds=[img_id]) anns = copy.deepcopy(coco.loadAnns(ids=ann_ids)) if '.npy' in img_path: img = np.load(img_path) else: assert os.path.exists(img_path), img_path img = cv2.imread(img_path) if self.args.cvt_gray: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img = np.tile(img[..., None], 3) img, anns = self._pad_image_boxes(img, anns) return img[..., ::-1], anns, img_info, img_path
def main(): img_seq = [] # Get img_ids from lvis, instead. img_ids = coco.getImgIds() num_images = len(img_ids) # import pdb; pdb.set_trace() prog_bar = mmcv.ProgressBar(len(img_ids)) ipdb.set_trace() if DEBUG_FOR_VIS: img_ids = random.sample(img_ids, 600) for i, img_id in enumerate(img_ids): # ipdb.set_trace() if DEBUG_ is True: if i == DEBUG_FRAMES: break img_info = coco.loadImgs(ids=[img_id])[0] img_path = IMG_PATH + img_info['file_name'] img = cv2.imread(img_path) gt_ids = coco.getAnnIds(imgIds=[img_id]) gts = coco.loadAnns(gt_ids) gt_img = img.copy() for j, pred in enumerate(gts): bbox = _coco_box_to_bbox(pred['bbox']) cat_id = pred['category_id'] gt_img = add_box(gt_img, bbox, 1.00, cat_id) # ipdb.set_trace() img_name = 'gt_{}.jpg'.format(str(img_id).zfill(12)) gt_img = add_to_canvas(gt_img) cv2.imwrite(os.path.join(OUT_PATH, img_name), gt_img) img_seq.append(gt_img) prog_bar.update() ipdb.set_trace() make_video(img_seq, VID_NAME)
def visualize(img_id): img_descriptor = coco.loadImgs(img_id) file_name = coco_data_folder + "val/" + img_descriptor[0]['file_name'] fig, ax = plt.subplots(1) img = mpimg.imread(file_name) ax.imshow(img) gt_ann_ids = coco.getAnnIds(imgIds=[img_id]) gt_anns = coco.loadAnns(gt_ann_ids) dets = detections_by_imgid[img_id] print("Image", img_id, "Dets", len(dets), "GT", len(gt_anns)) for gt in gt_anns: draw_box(ax, gt['bbox'], 'r', gt['category_id'], 1.0) for det in dets: draw_box(ax, det['bbox'], 'b', det['category_id'], det['score']) plt.show()
if __name__ == '__main__': dets = [] img_ids = coco.getImgIds() num_images = len(img_ids) for k in range(1, len(sys.argv)): pred_path = sys.argv[k] dets.append(coco.loadRes(pred_path)) # import pdb; pdb.set_trace() for i, img_id in enumerate(img_ids): img_info = coco.loadImgs(ids=[img_id])[0] img_path = IMG_PATH + img_info['file_name'] img = cv2.imread(img_path) gt_ids = coco.getAnnIds(imgIds=[img_id]) gts = coco.loadAnns(gt_ids) gt_img = img.copy() for j, pred in enumerate(gts): bbox = _coco_box_to_bbox(pred['bbox']) cat_id = pred['category_id'] gt_img = add_box(gt_img, bbox, 0, cat_id) for k in range(len(dets)): pred_ids = dets[k].getAnnIds(imgIds=[img_id]) preds = dets[k].loadAnns(pred_ids) pred_img = img.copy() for j, pred in enumerate(preds): bbox = _coco_box_to_bbox(pred['bbox']) sc = pred['score'] cat_id = pred['category_id'] if sc > 0.2: pred_img = add_box(pred_img, bbox, sc, cat_id)
if os.path.isfile(foutPrv): print('\timage already processed [%s]' % foutImg) continue # fimg = '%s/%s' % (dirImg, timgInfo['file_name']) timg = skio.imread(fimg) # assert (timg.ndim==3) if timg.ndim == 2: timg = skcl.gray2rgb(timg) twidth = timgInfo['width'] theight = timgInfo['height'] vv = tmpDictFoodImgIds[kk] tmsk = None for vvi in vv: tannIds = coco.getAnnIds(imgIds=kk, catIds=vvi, iscrowd=False) tanns = coco.loadAnns(tannIds) print('\t :: processing: %d -> %s' % (vvi, reversedDirFoods[vvi])) tmpMsk = None for ttt in tanns: rle = mask.frPyObjects(ttt['segmentation'], theight, twidth) tmpm = mask.decode(rle) if tmpm.shape[2] > 1: print('\t\t**** multiple shape out :( --> [%s]' % fimg) tmpm = np.sum(tmpm, axis=2) if tmpMsk is None: tmpMsk = tmpm else: tmpMsk += tmpm if tmsk is None: tmsk = np.zeros(tmpMsk.shape, dtype=tmpMsk.dtype) tmsk[tmpMsk > 0] = vvi
def simple_demo_example(): if False: annotation_filepath = '/path/to/annotation.json' data_dir_path = '/path/to/data' elif False: if 'posix' == os.name: data_base_dir_path = '/home/sangwook/work/dataset' else: data_base_dir_path = 'D:/work/dataset' publaynet_dir_path = data_base_dir_path + '/text/layout/publaynet/publaynet' #annotation_filepath = publaynet_dir_path + '/train.json' annotation_filepath = publaynet_dir_path + '/val.json' if 'train' in annotation_filepath: data_dir_path = publaynet_dir_path + '/train' elif 'val' in annotation_filepath: data_dir_path = publaynet_dir_path + '/val' else: print('Invalid directory tag.') return else: if 'posix' == os.name: data_base_dir_path = '/home/sangwook/work/dataset' else: data_base_dir_path = 'D:/work/dataset' coco_dir_path = data_base_dir_path + '/coco' annotation_filepath = coco_dir_path + '/annotations/instances_train2014.json' #annotation_filepath = coco_dir_path + '/annotations/instances_val2014.json' #annotation_filepath = coco_dir_path + '/annotations/instances_train2017.json' #annotation_filepath = coco_dir_path + '/annotations/instances_val2017.json' #annotation_filepath = coco_dir_path + '/annotations/person_keypoints_train2014.json' #annotation_filepath = coco_dir_path + '/annotations/person_keypoints_val2014.json' #annotation_filepath = coco_dir_path + '/annotations/person_keypoints_train2017.json' #annotation_filepath = coco_dir_path + '/annotations/person_keypoints_val2017.json' #annotation_filepath = coco_dir_path + '/annotations/captions_train2014.json' #annotation_filepath = coco_dir_path + '/annotations/captions_val2014.json' #annotation_filepath = coco_dir_path + '/annotations/captions_train2017.json' #annotation_filepath = coco_dir_path + '/annotations/captions_val2017.json' if 'train2014' in annotation_filepath: data_dir_path = coco_dir_path + '/train2014' elif 'val2014' in annotation_filepath: data_dir_path = coco_dir_path + '/val2014' elif 'train2017' in annotation_filepath: data_dir_path = coco_dir_path + '/train2017' elif 'val2017' in annotation_filepath: data_dir_path = coco_dir_path + '/val2017' else: print('Invalid directory tag.') return try: print( 'Start loading a COCO data from {}...'.format(annotation_filepath)) start_time = time.time() coco = pycocotools.coco.COCO(annotation_filepath) print('End loading a COCO data: {} secs.'.format(time.time() - start_time)) except UnicodeDecodeError as ex: print('Unicode decode error in {}: {}.'.format(annotation_filepath, ex)) return except FileNotFoundError as ex: print('File not found, {}: {}.'.format(annotation_filepath, ex)) return #-------------------- # REF [site] >> Data format. # https://cocodataset.org/#format-data # Show information on data. if True: #print('Dataset: {}.'.format(coco.dataset)) print('Dataset keys = {}.'.format(list(coco.dataset.keys()))) if 'info' in coco.dataset: #print('Info: {}.'.format(coco.dataset['info'])) print('Info: {}.'.format(coco.info())) if 'license' in coco.dataset: print('License: {}.'.format(coco.dataset['license'])) if 'images' in coco.dataset: print('Images:') #print('\tData: {}.'.format(coco.dataset['images'])) print('\tKeys = {}.'.format(list( coco.dataset['images'][0].keys()))) print('\t#images = {}.'.format(len(coco.dataset['images']))) print('\tMin and max IDs = ({}, {}).'.format( functools.reduce(lambda mm, img: min(mm, img['id']), coco.dataset['images'], coco.dataset['images'][0]['id']), functools.reduce(lambda mm, img: max(mm, img['id']), coco.dataset['images'], 0))) if 'categories' in coco.dataset: print('Categories:') #print('\tData: {}.'.format(coco.dataset['categories'])) print('\tKeys = {}.'.format( list(coco.dataset['categories'][0].keys()))) print('\t#categories = {}.'.format(len( coco.dataset['categories']))) print('\tMin and max IDs = ({}, {}).'.format( functools.reduce(lambda mm, cat: min(mm, cat['id']), coco.dataset['categories'], coco.dataset['categories'][0]['id']), functools.reduce(lambda mm, cat: max(mm, cat['id']), coco.dataset['categories'], 0))) print('\tCategory = {}.'.format( list(cat['name'] for cat in coco.dataset['categories']))) if 'annotations' in coco.dataset: print('Annotations:') #print('\tData: {}.'.format(coco.dataset['annotations'])) print('\tKeys = {}.'.format( list(coco.dataset['annotations'][0].keys()))) print('\t#annotations = {}.'.format( len(coco.dataset['annotations']))) print('\tMin and max IDs = ({}, {}).'.format( functools.reduce(lambda mm, ann: min(mm, ann['id']), coco.dataset['annotations'], coco.dataset['annotations'][0]['id']), functools.reduce(lambda mm, ann: max(mm, ann['id']), coco.dataset['annotations'], 0))) if 'segment_infos' in coco.dataset: print('Segment infos:') #print('\tData: {}.'.format(coco.dataset['segment_infos'])) print('\tKeys = {}.'.format( list(coco.dataset['segment_infos'][0].keys()))) print('\t#segment infos = {}.'.format( len(coco.dataset['segment_infos']))) print('\tMin and max IDs = ({}, {}).'.format( functools.reduce(lambda mm, si: min(mm, si['id']), coco.dataset['segment_infos'], coco.dataset['segment_infos'][0]['id']), functools.reduce(lambda mm, si: max(mm, si['id']), coco.dataset['segment_infos'], 0))) #-------------------- """ APIs for pycocotools.coco.COCO: annIds = coco.getAnnIds(imgIds=[], catIds=[], areaRng=[], iscrowd=None) catIds = coco.getCatIds(catNms=[], supNms=[], catIds=[]) imgIds = coco.getImgIds(imgIds=[], catIds=[]) anns = coco.loadAnns(ids=[]) cats = coco.loadCats(ids=[]) imgs = coco.loadImgs(ids=[]) coco_res = coco.loadRes(resFile) anns = coco.loadNumpyAnnotations(data) rle = coco.annToRLE(ann) mask = coco.annToMask(ann) import matplotlib.pyplot as plt coco.showAnns(anns, draw_bbox=False) plt.show() """ if 'categories' in coco.dataset: cat_counts = dict() for cat in coco.dataset['categories']: annIds = coco.getAnnIds(imgIds=[], catIds=[cat['id']], areaRng=[], iscrowd=None) cat_counts[cat['name']] = len(annIds) print("#annotations per category: {}.".format(cat_counts)) #imgIds = coco.getImgIds(imgIds=[1, 3, 7], catIds=[1]) #images = coco.loadImgs(ids=imgIds) #print('Image IDs = {}.'.format(imgIds)) #print('Images = {}.'.format(images)) #catIds = coco.getCatIds(catNms=[coco.dataset['categories'][1 - 1]['name'], coco.dataset['categories'][2 - 1]['name']], supNms=[], catIds=[2, 3]) #categories = coco.loadCats(ids=annIds) #print('Category IDs = {}.'.format(catIds)) #print('Categories = {}.'.format(categories)) #annIds = coco.getAnnIds(imgIds=[1], catIds=[], areaRng=[], iscrowd=None) #annotations = coco.loadAnns(ids=annIds) #print('Annotation IDs = {}.'.format(annIds)) #print('Annotation = {}.'.format(annotations)) #-------------------- # Visualize data. if True: import random num_data_to_visualize = 10 for image_info in random.sample( coco.dataset['images'], min(num_data_to_visualize, len(coco.dataset['images']))): image_filepath = image_info['file_name'] image_id = image_info['id'] image_height, image_width = image_info['height'], image_info[ 'width'] image_filepath = os.path.join(data_dir_path, image_filepath) annIds = coco.getAnnIds(imgIds=[image_id], catIds=[], areaRng=[], iscrowd=None) annotations = coco.loadAnns(ids=annIds) if True: import PIL.Image import matplotlib.pyplot as plt try: with PIL.Image.open(image_filepath) as img: if img.width != image_width or img.height != image_height: print('Invalid image size, ({}, {}) != ({}, {}).'. format(img.width, img.height, image_width, image_height)) return plt.imshow( visualize_coco_annotations(img, annotations, coco)) plt.tight_layout() plt.axis('off') except IOError as ex: print('Failed to load an image, {}: {}.'.format( image_filepath, ex)) raise plt.tight_layout() plt.show() else: import cv2 img = cv2.imread(image_filepath, cv2.IMREAD_COLOR) if img is None: print( 'Failed to load an image, {}.'.format(image_filepath)) return if img.shape[0] != image_height or img.shape[1] != image_width: print('Invalid image shape, ({}, {}) != ({}, {}).'.format( img.shape[0], img.shape[1], image_height, image_width)) return colors = [(0, 0, 255), (0, 255, 0), (255, 0, 0), (0, 255, 255), (255, 0, 255), (255, 255, 0)] print('Labels = {}.'.format( list(ann['category_id'] for ann in annotations))) for ann in annotations: bbox = ann['bbox'] # [x, y, width, height]. #area = ann['area'] segmentation = ann['segmentation'] # RLE or [polygon]. category_id = ann['category_id'] #iscrowd = ann['iscrowd'] # 0 or 1. assert len(segmentation) == 1 segmentation = segmentation[0] color = colors[(category_id - 1) % len(colors)] left, top, right, bottom = bbox[0], bbox[ 1], bbox[0] + bbox[2], bbox[1] + bbox[3] #assert left >= 0 and top >= 0 and right <= img.shape[1] and bottom <= img.shape[0], ((left, top, right, bottom), (img.shape)) left, top, right, bottom = max(math.floor(left), 0), max( math.floor(top), 0), min(math.ceil(right), img.shape[1] - 1), min(math.ceil(bottom), img.shape[0] - 1) cv2.rectangle(img, (left, top), (right, bottom), color, 2, cv2.LINE_8) segmentation = np.expand_dims(np.round( np.array( list(segmentation[si:si + 2] for si in range( 0, len(segmentation), 2)))).astype(np.int), axis=1) overlay = np.zeros_like(img) cv2.drawContours(overlay, [segmentation], 0, color, cv2.FILLED, cv2.LINE_8) img = cv2.addWeighted(img, 1.0, overlay, 0.25, 0) cv2.imshow('Image', img) cv2.waitKey(0)
dtype=np.float32) coco = coco.COCO(anno_path) images = coco.getImgIds() catIds = coco.getCatIds(class_name[-1]) assert catIds == _valid_ids images = coco.getImgIds(images, catIds) num_samples = len(images) index = np.random.randint(num_samples) img_id = images[index] file_name = coco.loadImgs(ids=[img_id])[0]['file_name'] img_path = os.path.join(img_dir, file_name) ann_ids = coco.getAnnIds(imgIds=[img_id]) anns = coco.loadAnns(ids=ann_ids) anns = list( filter(lambda x: x['category_id'] in _valid_ids and x['iscrowd'] != 1, anns)) num_objs = min(len(anns), max_objs) img = cv2.imread(img_path) print(file_name) print(img.shape) height, width = img.shape[0], img.shape[1] c = np.array([img.shape[1] / 2., img.shape[0] / 2.], dtype=np.float32) s = max(img.shape[0], img.shape[1]) * 1.0 rot = 0 print(c)
from pycocotools import coco import matplotlib.pyplot as plt import skimage.io as io import time time1 = time.time() annFile = '/media/zhuzhu/ec114170-f406-444f-bee7-a3dc0a86cfa2/dataset/coco/annotations/person_keypoints_val2017.json' dataDir = '/media/zhuzhu/ec114170-f406-444f-bee7-a3dc0a86cfa2/dataset/coco/images/val2017' saveDir = '/media/zhuzhu/ec114170-f406-444f-bee7-a3dc0a86cfa2/coco_ground/val2017' coco = coco.COCO(annFile) catIds = coco.getCatIds(catNms=['person']) imgIds = coco.getImgIds(catIds=catIds) for idx in imgIds: img = coco.loadImgs(ids=idx)[0] annIds = coco.getAnnIds(imgIds=idx, catIds=catIds) anns = coco.loadAnns(ids=annIds) plt.figure(idx) I = io.imread('%s/%s' % (dataDir, img['file_name'])) plt.imshow(I) plt.axis('off') coco.showAnns(anns=anns) plt.savefig('%s/%s' % (saveDir, img['file_name'])) plt.close() time2 = time.time() print('spent t = %.2f min' % ((time2 - time1) / 60))
def cache(config, path, category_index): phase = os.path.splitext(os.path.basename(path))[0] data = [] for i, row in pd.read_csv(os.path.splitext(__file__)[0] + '.tsv', sep='\t').iterrows(): logging.info('loading data %d (%s)' % (i, ', '.join([k + '=' + str(v) for k, v in row.items()]))) root = os.path.expanduser(os.path.expandvars(row['root'])) year = str(row['year']) suffix = phase + year path = os.path.join(root, 'annotations', 'instances_%s.json' % suffix) if not os.path.exists(path): logging.warning(path + ' not exists') continue coco = pycocotools.coco.COCO(path) catIds = coco.getCatIds(catNms=list(category_index.keys())) cats = coco.loadCats(catIds) id_index = dict( (cat['id'], category_index[cat['name']]) for cat in cats) imgIds = coco.getImgIds() path = os.path.join(root, suffix) imgs = coco.loadImgs(imgIds) _imgs = list( filter( lambda img: os.path.exists(os.path.join( path, img['file_name'])), imgs)) if len(imgs) > len(_imgs): logging.warning('%d of %d images not exists' % (len(imgs) - len(_imgs), len(imgs))) for img in tqdm.tqdm(_imgs): annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None) anns = coco.loadAnns(annIds) if len(anns) <= 0: continue path = os.path.join(path, img['file_name']) width, height = img['width'], img['height'] bbox = np.array([ann['bbox'] for ann in anns], dtype=np.float32) yx_min = bbox[:, 1::-1] hw = bbox[:, -1:1:-1] yx_max = yx_min + hw cls = np.array([id_index[ann['category_id']] for ann in anns], dtype=np.int) difficult = np.zeros(cls.shape, dtype=np.uint8) try: if config.getboolean('cache', 'verify'): size = (height, width) image = cv2.imread(path) assert image is not None assert image.shape[:2] == size[:2] utils.cache.verify_coords(yx_min, yx_max, size[:2]) except configparser.NoOptionError: pass assert len(yx_min) == len(cls) assert yx_min.shape == yx_max.shape assert len(yx_min.shape) == 2 and yx_min.shape[-1] == 2 data.append( dict(path=path, yx_min=yx_min, yx_max=yx_max, cls=cls, difficult=difficult)) logging.warning('%d of %d images are saved' % (len(data), len(_imgs))) return data
def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_map=None, return_coco=False, auto_download=False): """Load a subset of the COCO dataset. dataset_dir: The root directory of the COCO dataset. subset: What to load (train, val, minival, valminusminival) year: What dataset year to load (2014, 2017) as a string, not an integer class_ids: If provided, only loads images that have the given classes. class_map: TODO: Not implemented yet. Supports maping classes from different datasets to the same class ID. return_coco: If True, returns the COCO object. auto_download: Automatically download and unzip MS-COCO images and annotations """ if auto_download is True: self.auto_download(dataset_dir, subset, year) coco = COCO("{}/annotations/instances_{}{}.json".format( dataset_dir, subset, year)) if subset == "minival" or subset == "valminusminival": subset = "val" image_dir = "{}/{}{}".format(dataset_dir, subset, year) # Load all classes or a subset? if not class_ids: # All classes class_ids = sorted(coco.getCatIds()) # All images or a subset? if class_ids: image_ids = [] for id in class_ids: image_ids.extend(list(coco.getImgIds(catIds=[id]))) # Remove duplicates image_ids = list(set(image_ids)) else: # All images image_ids = list(coco.imgs.keys()) # Add classes for i in class_ids: self.add_class("coco", i, coco.loadCats(i)[0]["name"]) # Add images for i in image_ids: self.add_image("coco", image_id=i, path=os.path.join(image_dir, coco.imgs[i]['file_name']), width=coco.imgs[i]["width"], height=coco.imgs[i]["height"], annotations=coco.loadAnns( coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))) if return_coco: return coco