File size: 4,908 Bytes
d06f140 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
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() |