Datasets:

hamnaanaa
/

Duckietown-Multiclass-Semantic-Segmentation-Dataset

	import numpy as np
	import torch
	import torch.utils.data
	from PIL import Image, ImageDraw
	from torchvision import transforms

	from cvat_preprocessor import CVATPreprocessor

	DEBUG = True

	class DTSegmentationDataset(torch.utils.data.Dataset):
	"""
	Dataloader for the Duckietown dataset.
	Loads the images and the corresponding segmentation targets.
	"""
	PATH_TO_ANNOTATIONS = "offline learning/semantic segmentation/data/annotations/"
	PATH_TO_IMAGES = "offline learning/semantic segmentation/data/frames/"
	CVAT_XML_FILENAME = "segmentation_annotation.xml"
	SEGM_LABELS = {
	'Background': {'id': 0, 'rgb_value': [0, 0, 0]}, # black
	'Ego Lane': {'id': 1, 'rgb_value': [102, 255, 102]}, # green
	'Opposite Lane': {'id': 2, 'rgb_value': [245, 147, 49]}, # orange
	'Obstacle': {'id': 3, 'rgb_value': [184, 61, 245]}, # purple
	'Road End': {'id': 4, 'rgb_value': [250, 50, 83]}, # red
	'Intersection': {'id': 5, 'rgb_value': [50, 183, 250]}, # blue
	'Middle Lane': {'id': 6, 'rgb_value': [255, 255, 0]}, # yellow
	'Side Lane': {'id': 7, 'rgb_value': [255, 255, 255]}, # white
	}

	def __init__(self):
	super(DTSegmentationDataset, self).__init__()
	# Store the list of all image names
	self.imgs = CVATPreprocessor.get_all_image_names(self.PATH_TO_ANNOTATIONS + self.CVAT_XML_FILENAME)

	def __getitem__(self, idx):
	image_name = self.imgs[idx]
	if DEBUG:
	print(f"Fetching image {image_name}")
	# load the image
	img = Image.open(self.PATH_TO_IMAGES + image_name).convert("RGB")

	# load the associated segmentation mask (list of polygons)
	all_polygons = CVATPreprocessor.get_all_image_polygons(image_name, self.PATH_TO_ANNOTATIONS + self.CVAT_XML_FILENAME)

	# Create a target image with the same spacial dimensions as the original image
	# but a separate channel for each label
	target = np.zeros((640, 480)).astype(np.longlong)

	# Generate a random angle for rotation only once for both the image and the mask
	random_angle = np.random.randint(-10, 10)

	# Fill each channel with 1s where the corresponding label is present and 0s otherwise
	for label, polygons in all_polygons.items():
	# Create an empty bitmask for the current label and draw all label-associated polygons on it
	mask = Image.new('L', img.size, 0)
	drawer = ImageDraw.Draw(mask)
	for polygon in polygons:
	drawer.polygon(polygon, outline=255, fill=255)
	# Show the mask for extra debugging
	# mask.show()

	# Rotate the mask
	mask = transforms.Compose([
	transforms.Resize((640, 480))
	])(mask)
	mask = transforms.functional.rotate(mask, random_angle)

	mask = np.array(mask) == 255
	if DEBUG:
	print(f"Label '{label}' has {np.sum(mask)} pixels. Assigning them a value {self.SEGM_LABELS[label]['id']}")

	# Merge three road classes into one to improve the performance of the model
	if label in ['Ego Lane', 'Opposite Lane', 'Intersection']:
	target[mask] = self.SEGM_LABELS['Ego Lane']['id']
	else:
	target[mask] = self.SEGM_LABELS[label]['id']

	img = transforms.Compose([
	transforms.ToTensor(),
	transforms.Resize((640, 480)),
	transforms.ColorJitter(brightness=0.7, contrast=0.6, saturation=0.2),
	# Normalize the image with the mean and standard deviation of the ImageNet dataset
	transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
	])(img)
	img = transforms.functional.rotate(img, random_angle)

	target = torch.from_numpy(target)

	return img, target

	def __len__(self):
	return len(self.imgs)

	@staticmethod
	def label_img_to_rgb(label_img):
	"""
	Converts a label image (with one channel per label) to an RGB image.
	"""
	rgb_img = np.zeros((label_img.shape[0], label_img.shape[1], 3), dtype=np.uint8)
	for label, label_info in DTSegmentationDataset.SEGM_LABELS.items():
	mask = label_img == label_info['id']
	rgb_img[mask] = label_info['rgb_value']
	return rgb_img


	# ---------------------
	# Randomly select a batch of images and masks from the dataset
	# and visualize them to check if the dataloader works correctly

	if __name__ == "__main__":
	if DEBUG:
	dataset = DTSegmentationDataset()
	image, target = dataset[0]
	transforms.ToPILImage()(image).show()
	transforms.ToPILImage()(DTSegmentationDataset.label_img_to_rgb(target)).show()