def get_sample(self, index) -> DSample:
image_id = self.dataset_samples[index]
image_path = str(self._images_path / f'{image_id}.jpg')
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
mask_paths = self.image_id_to_masks[image_id]
# select random mask for an image
mask_path = str(self._masks_path / random.choice(mask_paths))
instances_mask = cv2.imread(mask_path)
instances_mask = cv2.cvtColor(instances_mask, cv2.COLOR_BGR2GRAY)
instances_mask[instances_mask > 0] = 1
instances_mask = instances_mask.astype(np.int32)
min_width = min(image.shape[1], instances_mask.shape[1])
min_height = min(image.shape[0], instances_mask.shape[0])
if image.shape[0] != min_height or image.shape[1] != min_width:
image = cv2.resize(image, (min_width, min_height),
interpolation=cv2.INTER_LINEAR)
if instances_mask.shape[0] != min_height or instances_mask.shape[
1] != min_width:
instances_mask = cv2.resize(instances_mask,
(min_width, min_height),
interpolation=cv2.INTER_NEAREST)
object_ids = [1] if instances_mask.sum() > 0 else []
return DSample(image,
instances_mask,
objects_ids=object_ids,
sample_id=index)
def get_sample(self, index) -> DSample:
sample_id = self.dataset_samples[index]
image_path = str(self._images_path / f'{sample_id}.jpg')
mask_path = str(self._insts_path / f'{sample_id}.png')
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
instances_mask = cv2.imread(mask_path)
instances_mask = cv2.cvtColor(instances_mask,
cv2.COLOR_BGR2GRAY).astype(np.int32)
if self.dataset_split == 'test':
instance_id = self.instance_ids[index]
mask = np.zeros_like(instances_mask)
mask[instances_mask == 220] = 220 # ignored area
mask[instances_mask == instance_id] = 1
objects_ids = [1]
instances_mask = mask
else:
objects_ids = np.unique(instances_mask)
objects_ids = [x for x in objects_ids if x != 0 and x != 220]
return DSample(image,
instances_mask,
objects_ids=objects_ids,
ignore_ids=[220],
sample_id=index)
def get_sample(self, index) -> DSample:
image_id = self.dataset_samples[index]
sample_annos = self.annotations[image_id]
image_path = str(self.dataset_path / sample_annos['folder'] /
f'{image_id}.jpg')
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# select random mask for an image
layer = random.choice(sample_annos['layers'])
mask_path = str(self.dataset_path / sample_annos['folder'] /
layer['mask_name'])
instances_mask = cv2.imread(
mask_path,
cv2.IMREAD_UNCHANGED)[:, :, 0] # the B channel holds instances
instances_mask = instances_mask.astype(np.int32)
object_ids, _ = get_labels_with_sizes(instances_mask)
if (self.stuff_prob <= 0) or (random.random() > self.stuff_prob):
# remove stuff objects
for i, object_id in enumerate(object_ids):
if i in layer['stuff_instances']:
instances_mask[instances_mask == object_id] = 0
object_ids, _ = get_labels_with_sizes(instances_mask)
return DSample(image,
instances_mask,
objects_ids=object_ids,
sample_id=index)
def get_sample(self, index) -> DSample:
image_name = self.dataset_samples[index]
image_path = str(self._images_path / image_name)
mask_path = str(self._masks_paths[image_name.split('.')[0]])
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
instances_mask = np.max(cv2.imread(mask_path).astype(np.int32), axis=2)
instances_mask[instances_mask > 0] = 1
return DSample(image, instances_mask, objects_ids=[1], sample_id=index)
def get_sample(self, index) -> DSample:
image_name, instance_id = self.dataset_samples[index]
image_path = str(self._images_path / f'{image_name}.jpg')
inst_info_path = str(self._insts_path / f'{image_name}.mat')
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
instances_mask = loadmat(
str(inst_info_path))['GTinst'][0][0][0].astype(np.int32)
instances_mask[instances_mask != instance_id] = 0
instances_mask[instances_mask > 0] = 1
return DSample(image, instances_mask, objects_ids=[1], sample_id=index)
def get_sample(self, index):
image_name = self.dataset_samples[index]
image_path = str(self._images_path / f'{image_name}.jpg')
inst_info_path = str(self._insts_path / f'{image_name}.mat')
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
instances_mask = loadmat(
str(inst_info_path))['GTinst'][0][0][0].astype(np.int32)
instances_mask = self.remove_buggy_masks(index, instances_mask)
instances_ids, _ = get_labels_with_sizes(instances_mask)
return DSample(image,
instances_mask,
objects_ids=instances_ids,
sample_id=index)
def get_sample(self, index) -> DSample:
image_info = self.dataset_samples[index]
image_id, image_url = image_info['id'], image_info['coco_url']
image_filename = image_url.split('/')[-1]
image_annotations = self.annotations[image_id]
random.shuffle(image_annotations)
# LVISv1 splits do not match older LVIS splits (some images in val may come from COCO train2017)
if 'train2017' in image_url:
image_path = self._train_path / 'images' / image_filename
else:
image_path = self._val_path / 'images' / image_filename
image = cv2.imread(str(image_path))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
instances_mask = None
instances_area = defaultdict(int)
objects_ids = []
for indx, obj_annotation in enumerate(image_annotations):
mask = self.get_mask_from_polygon(obj_annotation, image)
object_mask = mask > 0
object_area = object_mask.sum()
if instances_mask is None:
instances_mask = np.zeros_like(object_mask, dtype=np.int32)
overlap_ids = np.bincount(instances_mask[object_mask].flatten())
overlap_areas = [
overlap_area / instances_area[inst_id]
for inst_id, overlap_area in enumerate(overlap_ids)
if overlap_area > 0 and inst_id > 0
]
overlap_ratio = np.logical_and(
object_mask, instances_mask > 0).sum() / object_area
if overlap_areas:
overlap_ratio = max(overlap_ratio, max(overlap_areas))
if overlap_ratio > self.max_overlap_ratio:
continue
instance_id = indx + 1
instances_mask[object_mask] = instance_id
instances_area[instance_id] = object_area
objects_ids.append(instance_id)
return DSample(image, instances_mask, objects_ids=objects_ids)
def get_sample(self, index) -> DSample:
dataset_sample = self.dataset_samples[index]
image_path = self.images_path / self.get_image_name(
dataset_sample['file_name'])
label_path = self.labels_path / dataset_sample['file_name']
image = cv2.imread(str(image_path))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
label = cv2.imread(str(label_path),
cv2.IMREAD_UNCHANGED).astype(np.int32)
label = 256 * 256 * label[:, :, 0] + 256 * label[:, :, 1] + label[:, :,
2]
instance_map = np.full_like(label, 0)
things_ids = []
stuff_ids = []
for segment in dataset_sample['segments_info']:
class_id = segment['category_id']
obj_id = segment['id']
if class_id in self._things_labels_set:
if segment['iscrowd'] == 1:
continue
things_ids.append(obj_id)
else:
stuff_ids.append(obj_id)
instance_map[label == obj_id] = obj_id
if self.stuff_prob > 0 and random.random() < self.stuff_prob:
instances_ids = things_ids + stuff_ids
else:
instances_ids = things_ids
for stuff_id in stuff_ids:
instance_map[instance_map == stuff_id] = 0
return DSample(image, instance_map, objects_ids=instances_ids)
def get_sample(self, index) -> DSample:
image_id, sample = self.dataset_samples[index]
image_path = self._images_path / f'{image_id}.jpg'
image = cv2.imread(str(image_path))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
packed_masks_path = self._masks_path / f'{image_id}.pickle'
with open(packed_masks_path, 'rb') as f:
encoded_layers, objs_mapping = pickle.load(f)
layers = [
cv2.imdecode(x, cv2.IMREAD_UNCHANGED) for x in encoded_layers
]
layers = np.stack(layers, axis=2)
instances_info = deepcopy(sample['hierarchy'])
for inst_id, inst_info in list(instances_info.items()):
if inst_info is None:
inst_info = {'children': [], 'parent': None, 'node_level': 0}
instances_info[inst_id] = inst_info
inst_info['mapping'] = objs_mapping[inst_id]
if self.stuff_prob > 0 and random.random() < self.stuff_prob:
for inst_id in range(sample['num_instance_masks'],
len(objs_mapping)):
instances_info[inst_id] = {
'mapping': objs_mapping[inst_id],
'parent': None,
'children': []
}
else:
for inst_id in range(sample['num_instance_masks'],
len(objs_mapping)):
layer_indx, mask_id = objs_mapping[inst_id]
layers[:, :, layer_indx][layers[:, :,
layer_indx] == mask_id] = 0
return DSample(image, layers, objects=instances_info)
def get_sample(self, index) -> DSample:
sample = self.dataset_samples[index]
image_path = str(sample['image'])
objects = []
ignored_regions = []
masks = []
for indx, mask_path in enumerate(sample['masks']):
gt_mask = cv2.imread(str(mask_path))[:, :, 0].astype(np.int32)
instances_mask = np.zeros_like(gt_mask)
instances_mask[gt_mask == 128] = 2
instances_mask[gt_mask > 128] = 1
masks.append(instances_mask)
objects.append((indx, 1))
ignored_regions.append((indx, 2))
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return DSample(image,
np.stack(masks, axis=2),
objects_ids=objects,
ignore_ids=ignored_regions,
sample_id=index)