Upload 2 files

cvat_preprocessor.py

@@ -0,0 +1,43 @@
+import xml.etree.ElementTree as ET
+
+
+class CVATPreprocessor():
+    """Helper class to preprocess annotations in `CVAT for images 1.1` XML-encoded format"""
+    @staticmethod
+    def get_all_image_names(annotation_path):
+        """Returns a list of all image names present in the annotation file"""
+        annotations = ET.parse(annotation_path).getroot()
+        images = annotations.findall("image")
+        return [image.attrib["name"] for image in images]
+
+    @staticmethod
+    def get_all_image_polygons(image_name, annotation_path):
+        """
+        Returns a dictionary of all polygons for the given image name.
+        The key is the label and the value is a list of polygons (= each a list of points) associated with that label.
+        """
+        annotations = ET.parse(annotation_path).getroot()
+        image = annotations.find(f"image[@name='{image_name}']")
+        raw_polygons = image.findall("polygon")
+        
+        # Extract the label and the raw points for each polygon, 
+        # parse the points to (x, y) and store each label-polygon pair in a list
+        processed_polygons = {}
+        for raw_polygon in raw_polygons:
+            label, points = raw_polygon.attrib["label"], raw_polygon.attrib["points"].split(";")
+            # Parse the points to (x, y) int pairs
+            points = [(int(float(point.split(",")[0])), int(float(point.split(",")[1]))) for point in points]
+            processed_polygons[label] = processed_polygons.get(label, []) + [points]
+
+        return processed_polygons
+
+
+if __name__ == "__main__":
+    # Example usage
+    PATH_TO_ANNOTATIONS = "offline learning/semantic segmentation/data/annotations/"
+    PATH_TO_IMAGES = "offline learning/semantic segmentation/data/frames/"
+    CVAT_XML_FILENAME = "segmentation_annotation.xml"
+    imgs = CVATPreprocessor.get_all_image_names(PATH_TO_ANNOTATIONS + CVAT_XML_FILENAME)
+    polygons = CVATPreprocessor.get_all_image_polygons(imgs[0], PATH_TO_ANNOTATIONS + CVAT_XML_FILENAME)
+    print(f"Loaded {len(imgs)} images from {PATH_TO_ANNOTATIONS + CVAT_XML_FILENAME}")
+    print(f"Image '{imgs[0]} has {len(polygons)} polygon categories")

dataloader.py

@@ -0,0 +1,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()