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
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
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)
sample_area_num = 10
area_list = np.random.permutation(len(anns))[0:sample_area_num]
scribbles = np.zeros([I.shape[0], I.shape[1]])
start = time.clock()
for i in area_list:
area_scribbles = np.zeros([I.shape[0], I.shape[1]])
mask = coco.annToMask(anns[i])
class COCOYoloDataset:
"""YOLOV4 Dataset for COCO."""
def __init__(self, root, ann_file, remove_images_without_annotations=True,
filter_crowd_anno=True, is_training=True):
self.coco = COCO(ann_file)
self.root = root
self.img_ids = list(sorted(self.coco.imgs.keys()))
self.filter_crowd_anno = filter_crowd_anno
self.is_training = is_training
# filter images without any annotations
if remove_images_without_annotations:
img_ids = []
for img_id in self.img_ids:
ann_ids = self.coco.getAnnIds(imgIds=img_id, iscrowd=None)
anno = self.coco.loadAnns(ann_ids)
if has_valid_annotation(anno):
img_ids.append(img_id)
self.img_ids = img_ids
self.categories = {cat["id"]: cat["name"] for cat in self.coco.cats.values()}
self.cat_ids_to_continuous_ids = {
v: i for i, v in enumerate(self.coco.getCatIds())
}
self.continuous_ids_cat_ids = {
v: k for k, v in self.cat_ids_to_continuous_ids.items()
}
def __getitem__(self, index):
"""
Args:
index (int): Index
Returns:
(img, target) (tuple): target is a dictionary contains "bbox", "segmentation" or "keypoints",
generated by the image's annotation. img is a PIL image.
"""
coco = self.coco
img_id = self.img_ids[index]
img_path = coco.loadImgs(img_id)[0]["file_name"]
img = Image.open(os.path.join(self.root, img_path)).convert("RGB")
if not self.is_training:
return img, img_id
ann_ids = coco.getAnnIds(imgIds=img_id)
target = coco.loadAnns(ann_ids)
# filter crowd annotations
if self.filter_crowd_anno:
annos = [anno for anno in target if anno["iscrowd"] == 0]
else:
annos = [anno for anno in target]
target = {}
boxes = [anno["bbox"] for anno in annos]
target["bboxes"] = boxes
classes = [anno["category_id"] for anno in annos]
classes = [self.cat_ids_to_continuous_ids[cl] for cl in classes]
target["labels"] = classes
bboxes = target['bboxes']
labels = target['labels']
out_target = []
for bbox, label in zip(bboxes, labels):
tmp = []
# convert to [x_min y_min x_max y_max]
bbox = self._conve_top_down(bbox)
tmp.extend(bbox)
tmp.append(int(label))
# tmp [x_min y_min x_max y_max, label]
out_target.append(tmp)
return img, out_target, [], [], [], [], [], []
def __len__(self):
return len(self.img_ids)
def _conve_top_down(self, bbox):
x_min = bbox[0]
y_min = bbox[1]
w = bbox[2]
h = bbox[3]
return [x_min, y_min, x_min+w, y_min+h]