kubeedge
/
sedna
Not watched
1
0
Fork 0
Code
Releases 12 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 2a003ec7ca
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2a003ec7ca'
${ noResults }
sedna/examples/lifelong_learning/cityscapes/RFNet/dataloaders/utils.py

259 lines
8.3 kB
Raw Blame History 

  1. import matplotlib.pyplot as plt

  2. import numpy as np

  3. import torch

  4. 

  5. def decode_seg_map_sequence(label_masks, dataset='pascal'):

  6.     rgb_masks = []

  7.     for label_mask in label_masks:

  8.         rgb_mask = decode_segmap(label_mask, dataset)

  9.         rgb_masks.append(rgb_mask)

  10.     rgb_masks = torch.from_numpy(np.array(rgb_masks).transpose([0, 3, 1, 2]))  # change for val

  11.     return rgb_masks

  12. 

  13. 

  14. def decode_segmap(label_mask, dataset, plot=False):

  15.     """Decode segmentation class labels into a color image

  16.     Args:

  17.         label_mask (np.ndarray): an (M,N) array of integer values denoting

  18.           the class label at each spatial location.

  19.         plot (bool, optional): whether to show the resulting color image

  20.           in a figure.

  21.     Returns:

  22.         (np.ndarray, optional): the resulting decoded color image.

  23.     """

  24.     if dataset == 'pascal' or dataset == 'coco':

  25.         n_classes = 21

  26.         label_colours = get_pascal_labels()

  27.     elif dataset == 'cityscapes':

  28.         n_classes = 24

  29.         label_colours = get_cityscapes_labels()

  30.     elif dataset == 'target':

  31.         n_classes = 24

  32.         label_colours = get_cityscapes_labels()

  33.     elif dataset == 'cityrand':

  34.         n_classes = 19

  35.         label_colours = get_cityscapes_labels()

  36.     elif dataset == 'citylostfound':

  37.         n_classes = 20

  38.         label_colours = get_citylostfound_labels()

  39.     elif dataset == 'xrlab':

  40.         n_classes = 25

  41.         label_colours = get_cityscapes_labels()

  42.     elif dataset == 'e1':

  43.         n_classes = 24

  44.         label_colours = get_cityscapes_labels()

  45.     elif dataset == 'mapillary':

  46.         n_classes = 24

  47.         label_colours = get_cityscapes_labels()

  48.     else:

  49.         raise NotImplementedError

  50. 

  51.     r = label_mask.copy()

  52.     g = label_mask.copy()

  53.     b = label_mask.copy()

  54.     for ll in range(0, n_classes):

  55.         r[label_mask == ll] = label_colours[ll, 0]

  56.         g[label_mask == ll] = label_colours[ll, 1]

  57.         b[label_mask == ll] = label_colours[ll, 2]

  58.     rgb = np.zeros((label_mask.shape[0], label_mask.shape[1], 3))  # change for val

  59.     # rgb = torch.ByteTensor(3, label_mask.shape[0], label_mask.shape[1]).fill_(0)

  60.     rgb[:, :, 0] = r / 255.0

  61.     rgb[:, :, 1] = g / 255.0

  62.     rgb[:, :, 2] = b / 255.0

  63.     # r = torch.from_numpy(r)

  64.     # g = torch.from_numpy(g)

  65.     # b = torch.from_numpy(b)

  66. 

  67.     rgb[:, :, 0] = r / 255.0

  68.     rgb[:, :, 1] = g / 255.0

  69.     rgb[:, :, 2] = b / 255.0

  70.     if plot:

  71.         plt.imshow(rgb)

  72.         plt.show()

  73.     else:

  74.         return rgb

  75. 

  76. 

  77. def encode_segmap(mask):

  78.     """Encode segmentation label images as pascal classes

  79.     Args:

  80.         mask (np.ndarray): raw segmentation label image of dimension

  81.           (M, N, 3), in which the Pascal classes are encoded as colours.

  82.     Returns:

  83.         (np.ndarray): class map with dimensions (M,N), where the value at

  84.         a given location is the integer denoting the class index.

  85.     """

  86.     mask = mask.astype(int)

  87.     label_mask = np.zeros((mask.shape[0], mask.shape[1]), dtype=np.int16)

  88.     for ii, label in enumerate(get_pascal_labels()):

  89.         label_mask[np.where(np.all(mask == label, axis=-1))[:2]] = ii

  90.     label_mask = label_mask.astype(int)

  91.     return label_mask

  92. 

  93. 

  94. def get_cityscapes_labels():

  95.     return np.array([

  96.         [128, 64, 128],

  97.         [244, 35, 232],

  98.         [70, 70, 70],

  99.         [102, 102, 156],

  100.         [190, 153, 153],

  101.         [153, 153, 153],

  102.         [250, 170, 30],

  103.         [220, 220, 0],

  104.         [107, 142, 35],

  105.         [152, 251, 152],

  106.         [0, 130, 180],

  107.         [220, 20, 60],

  108.         [255, 0, 0],

  109.         [0, 0, 142],

  110.         [0, 0, 70],

  111.         [0, 60, 100],

  112.         [0, 80, 100],

  113.         [0, 0, 230],

  114.         [119, 11, 32],

  115.         [119, 11, 119],

  116.         [128, 64, 64],

  117.         [102, 10,  156],

  118.         [102, 102,  15],

  119.         [10, 102,  156],

  120.         [10, 102,  156],

  121.         [10, 102,  156],

  122.         [10, 102,  156]])

  123. 

  124. def get_citylostfound_labels():

  125.     return np.array([

  126.         [128, 64, 128],

  127.         [244, 35, 232],

  128.         [70, 70, 70],

  129.         [102, 102, 156],

  130.         [190, 153, 153],

  131.         [153, 153, 153],

  132.         [250, 170, 30],

  133.         [220, 220, 0],

  134.         [107, 142, 35],

  135.         [152, 251, 152],

  136.         [0, 130, 180],

  137.         [220, 20, 60],

  138.         [255, 0, 0],

  139.         [0, 0, 142],

  140.         [0, 0, 70],

  141.         [0, 60, 100],

  142.         [0, 80, 100],

  143.         [0, 0, 230],

  144.         [119, 11, 32],

  145.         [111, 74,  0]])

  146. 

  147. 

  148. def get_pascal_labels():

  149.     """Load the mapping that associates pascal classes with label colors

  150.     Returns:

  151.         np.ndarray with dimensions (21, 3)

  152.     """

  153.     return np.asarray([[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],

  154.                        [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],

  155.                        [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],

  156.                        [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],

  157.                        [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],

  158.                        [0, 64, 128]])

  159. 

  160. 

  161. def colormap_bdd(n):

  162.     cmap=np.zeros([n, 3]).astype(np.uint8)

  163.     cmap[0,:] = np.array([128, 64, 128])

  164.     cmap[1,:] = np.array([244, 35, 232])

  165.     cmap[2,:] = np.array([ 70, 70, 70])

  166.     cmap[3,:] = np.array([102, 102, 156])

  167.     cmap[4,:] = np.array([190, 153, 153])

  168.     cmap[5,:] = np.array([153, 153, 153])

  169. 

  170.     cmap[6,:] = np.array([250, 170, 30])

  171.     cmap[7,:] = np.array([220, 220, 0])

  172.     cmap[8,:] = np.array([107, 142, 35])

  173.     cmap[9,:] = np.array([152, 251, 152])

  174.     cmap[10,:]= np.array([70, 130, 180])

  175. 

  176.     cmap[11,:]= np.array([220, 20, 60])

  177.     cmap[12,:]= np.array([255, 0, 0])

  178.     cmap[13,:]= np.array([0, 0, 142])

  179.     cmap[14,:]= np.array([0, 0, 70])

  180.     cmap[15,:]= np.array([0, 60, 100])

  181. 

  182.     cmap[16,:]= np.array([0, 80, 100])

  183.     cmap[17,:]= np.array([0, 0, 230])

  184.     cmap[18,:]= np.array([119, 11, 32])

  185.     cmap[19,:]= np.array([111, 74, 0]) #多加了一类small obstacle

  186. 

  187.     # supplemented class rgb

  188.     cmap[20, :] = np.array([0, 10, 128])

  189.     cmap[21, :] = np.array([0, 100, 232])

  190.     cmap[22, :] = np.array([250, 70, 70])

  191.     cmap[23, :] = np.array([0, 102, 156])

  192.     cmap[24, :] = np.array([190, 153, 0])

  193.     cmap[25, :] = np.array([153, 153, 255])

  194. 

  195.     cmap[26, :] = np.array([250, 170, 0])

  196.     cmap[27, :] = np.array([150, 220, 0])

  197.     cmap[28, :] = np.array([107, 0, 35])

  198.     cmap[29, :] = np.array([0, 251, 152])

  199.     cmap[30, :] = np.array([70, 255, 180])

  200. 

  201.     return cmap

  202. 

  203. def colormap_bdd0(n):

  204.     cmap=np.zeros([n, 3]).astype(np.uint8)

  205.     cmap[0,:] = np.array([0, 0, 0])

  206.     cmap[1,:] = np.array([70, 130, 180])

  207.     cmap[2,:] = np.array([70, 70, 70])

  208.     cmap[3,:] = np.array([128, 64, 128])

  209.     cmap[4,:] = np.array([244, 35, 232])

  210.     cmap[5,:] = np.array([64, 64, 128])

  211. 

  212.     cmap[6,:] = np.array([107, 142, 35])

  213.     cmap[7,:] = np.array([153, 153, 153])

  214.     cmap[8,:] = np.array([0, 0, 142])

  215.     cmap[9,:] = np.array([220, 220, 0])

  216.     cmap[10,:]= np.array([220, 20, 60])

  217. 

  218.     cmap[11,:]= np.array([119, 11, 32])

  219.     cmap[12,:]= np.array([0, 0, 230])

  220.     cmap[13,:]= np.array([250, 170, 160])

  221.     cmap[14,:]= np.array([128, 64, 64])

  222.     cmap[15,:]= np.array([250, 170, 30])

  223. 

  224.     cmap[16,:]= np.array([152, 251, 152])

  225.     cmap[17,:]= np.array([255, 0, 0])

  226.     cmap[18,:]= np.array([0, 0, 70])

  227.     cmap[19,:]= np.array([0, 60,  100]) #small obstacle

  228.     cmap[20,:]= np.array([0, 80,  100])

  229.     cmap[21,:]= np.array([102, 102,  156])

  230.     cmap[22,:]= np.array([102, 102,  156])

  231. 

  232.     return cmap

  233. 

  234. class Colorize:

  235. 

  236.     def __init__(self, n=31): # n = nClasses

  237.         # self.cmap = colormap(256)

  238.         self.cmap = colormap_bdd(256)

  239.         self.cmap[n] = self.cmap[-1]

  240.         self.cmap = torch.from_numpy(self.cmap[:n])

  241. 

  242.     def __call__(self, gray_image):

  243.         size = gray_image.size()

  244.         # print(size)

  245.         color_images = torch.ByteTensor(size[0], 3, size[1], size[2]).fill_(0)

  246.         # color_image = torch.ByteTensor(3, size[0], size[1]).fill_(0)

  247. 

  248.         # for label in range(1, len(self.cmap)):

  249.         for i in range(color_images.shape[0]):

  250.             for label in range(0, len(self.cmap)):

  251.                 mask = gray_image[0] == label

  252.                 # mask = gray_image == label

  253. 

  254.                 color_images[i][0][mask] = self.cmap[label][0]

  255.                 color_images[i][1][mask] = self.cmap[label][1]

  256.                 color_images[i][2][mask] = self.cmap[label][2]

  257. 

  258.         return color_images