sbd.py 5.31 KB
Newer Older
1
import os
2
import shutil
3
from .vision import VisionDataset
4
from typing import Any, Callable, Optional, Tuple
5
6
7
8

import numpy as np

from PIL import Image
9
from .utils import download_url, verify_str_arg, download_and_extract_archive
10
11


12
class SBDataset(VisionDataset):
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
    """`Semantic Boundaries Dataset <http://home.bharathh.info/pubs/codes/SBD/download.html>`_

    The SBD currently contains annotations from 11355 images taken from the PASCAL VOC 2011 dataset.

    .. note ::

        Please note that the train and val splits included with this dataset are different from
        the splits in the PASCAL VOC dataset. In particular some "train" images might be part of
        VOC2012 val.
        If you are interested in testing on VOC 2012 val, then use `image_set='train_noval'`,
        which excludes all val images.

    .. warning::

        This class needs `scipy <https://docs.scipy.org/doc/>`_ to load target files from `.mat` format.

    Args:
        root (string): Root directory of the Semantic Boundaries Dataset
        image_set (string, optional): Select the image_set to use, ``train``, ``val`` or ``train_noval``.
            Image set ``train_noval`` excludes VOC 2012 val images.
        mode (string, optional): Select target type. Possible values 'boundaries' or 'segmentation'.
            In case of 'boundaries', the target is an array of shape `[num_classes, H, W]`,
            where `num_classes=20`.
        download (bool, optional): If true, downloads the dataset from the internet and
            puts it in root directory. If dataset is already downloaded, it is not
            downloaded again.
39
        transforms (callable, optional): A function/transform that takes input sample and its target as entry
40
41
42
43
44
45
46
47
48
49
50
51
            and returns a transformed version. Input sample is PIL image and target is a numpy array
            if `mode='boundaries'` or PIL image if `mode='segmentation'`.
    """

    url = "http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz"
    md5 = "82b4d87ceb2ed10f6038a1cba92111cb"
    filename = "benchmark.tgz"

    voc_train_url = "http://home.bharathh.info/pubs/codes/SBD/train_noval.txt"
    voc_split_filename = "train_noval.txt"
    voc_split_md5 = "79bff800c5f0b1ec6b21080a3c066722"

52
53
54
55
56
57
58
59
    def __init__(
            self,
            root: str,
            image_set: str = "train",
            mode: str = "boundaries",
            download: bool = False,
            transforms: Optional[Callable] = None,
    ) -> None:
60
61
62
63
64
65
66
67

        try:
            from scipy.io import loadmat
            self._loadmat = loadmat
        except ImportError:
            raise RuntimeError("Scipy is not found. This dataset needs to have scipy installed: "
                               "pip install scipy")

68
        super(SBDataset, self).__init__(root, transforms)
69
70
71
        self.image_set = verify_str_arg(image_set, "image_set",
                                        ("train", "val", "train_noval"))
        self.mode = verify_str_arg(mode, "mode", ("segmentation", "boundaries"))
72
73
        self.num_classes = 20

74
        sbd_root = self.root
75
76
77
78
        image_dir = os.path.join(sbd_root, 'img')
        mask_dir = os.path.join(sbd_root, 'cls')

        if download:
79
            download_and_extract_archive(self.url, self.root, filename=self.filename, md5=self.md5)
80
81
82
83
            extracted_ds_root = os.path.join(self.root, "benchmark_RELEASE", "dataset")
            for f in ["cls", "img", "inst", "train.txt", "val.txt"]:
                old_path = os.path.join(extracted_ds_root, f)
                shutil.move(old_path, sbd_root)
84
85
86
87
88
89
90
91
92
            download_url(self.voc_train_url, sbd_root, self.voc_split_filename,
                         self.voc_split_md5)

        if not os.path.isdir(sbd_root):
            raise RuntimeError('Dataset not found or corrupted.' +
                               ' You can use download=True to download it')

        split_f = os.path.join(sbd_root, image_set.rstrip('\n') + '.txt')

93
94
        with open(os.path.join(split_f), "r") as fh:
            file_names = [x.strip() for x in fh.readlines()]
95
96
97
98
99
100
101
102

        self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names]
        self.masks = [os.path.join(mask_dir, x + ".mat") for x in file_names]
        assert (len(self.images) == len(self.masks))

        self._get_target = self._get_segmentation_target \
            if self.mode == "segmentation" else self._get_boundaries_target

103
    def _get_segmentation_target(self, filepath: str) -> Image.Image:
104
105
106
        mat = self._loadmat(filepath)
        return Image.fromarray(mat['GTcls'][0]['Segmentation'][0])

107
    def _get_boundaries_target(self, filepath: str) -> np.ndarray:
108
109
110
111
        mat = self._loadmat(filepath)
        return np.concatenate([np.expand_dims(mat['GTcls'][0]['Boundaries'][0][i][0].toarray(), axis=0)
                               for i in range(self.num_classes)], axis=0)

112
    def __getitem__(self, index: int) -> Tuple[Any, Any]:
113
114
115
        img = Image.open(self.images[index]).convert('RGB')
        target = self._get_target(self.masks[index])

116
117
        if self.transforms is not None:
            img, target = self.transforms(img, target)
118
119
120

        return img, target

121
    def __len__(self) -> int:
122
        return len(self.images)
123

124
    def extra_repr(self) -> str:
125
126
        lines = ["Image set: {image_set}", "Mode: {mode}"]
        return '\n'.join(lines).format(**self.__dict__)