rm unused

encoding/datasets/cityscapes.py

-###########################################################################
-# Created by: Hang Zhang
-# Email: zhang.hang@rutgers.edu
-# Copyright (c) 2017
-###########################################################################
-
-import os
-import sys
-import numpy as np
-import random
-import math
-from tqdm import tqdm
-from PIL import Image, ImageOps, ImageFilter
-
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transform
-
-class Segmentation(data.Dataset):
-    BASE_DIR = 'cityscapes'
-    
-    def __init__(self, data_folder, mode='train', transform=None, 
-                 target_transform=None):
-        self.root = os.path.join(data_folder, self.BASE_DIR)
-        self.transform = transform
-        self.target_transform = target_transform
-        self.mode = mode
-        self.images, self.masks = get_city_pairs(self.root, mode)
-        assert (len(self.images) == len(self.masks))
-        print("Found {} images in subfolders of: {}\
-                ".format(len(self.images), self.root + '/' + mode))
-        if len(self.images) == 0:
-            raise(RuntimeError("Found 0 images in subfolders of: \
-                " + self.root + "\n"))
-
-    def __getitem__(self, index):
-        img = Image.open(self.images[index]).convert('RGB')
-        if self.mode == 'test':
-            if self.transform is not None:
-                img = self.transform(img)
-            return img, os.path.basename(self.images[index])
-
-        mask = Image.open(self.masks[index])#.convert("P")
-        mask = np.array(mask) 
-        mask += 1
-        mask[mask==256] = 0
-        mask = Image.fromarray(mask)
-        # synchrosized transform
-        if self.mode == 'train':
-            img, mask = self._sync_transform(img, mask)
-        elif self.mode == 'val':
-            img, mask = self._val_sync_transform(img, mask)
-        else:
-            raise RuntimeError('unknown mode for dataloader: {}'.format(self.mode))
-
-        # general resize, normalize and toTensor
-        if self.transform is not None:
-            #print("transform for input")
-            img = self.transform(img)
-        if self.target_transform is not None:
-            #print("transform for label")
-            mask = self.target_transform(mask)
-
-        return img, mask
-
-    def __len__(self):
-        return len(self.images)
-
-    def _val_sync_transform(self, img, mask):
-        """
-        synchronized transformation
-        """
-        outsize = 720
-        short = outsize
-        w, h = img.size
-        if w > h:
-            oh = short
-            ow = int(1.0 * w * oh / h)
-        else:
-            ow = short
-            oh = int(1.0 * h * ow / w)
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # center crop
-        w, h = img.size
-        x1 = int(round((w - outsize) / 2.))
-        y1 = int(round((h - outsize) / 2.))
-        img = img.crop((x1, y1, x1+outsize, y1+outsize))
-        mask = mask.crop((x1, y1, x1+outsize, y1+outsize))
-
-        return img, mask
-
-    def _sync_transform(self, img, mask):
-        # random mirror
-        if random.random() < 0.5:
-            img  = img.transpose(Image.FLIP_LEFT_RIGHT)
-            mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
-        base_size = 2048
-        crop_size = 720
-        # random scale (short edge from 480 to 720)
-        long_size = random.randint(int(base_size*0.5), int(base_size*2.0))
-        w, h = img.size
-        if h > w:
-            oh = long_size
-            ow = int(1.0 * w * oh / h)
-            short_size = ow
-        else:
-            ow = long_size
-            oh = int(1.0 * h * ow / w)
-            short_size = oh
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # random rotate -10~10, mask using NN rotate
-        deg = random.uniform(-10,10)
-        img = img.rotate(deg, resample=Image.BILINEAR)
-        mask = mask.rotate(deg, resample=Image.NEAREST)
-        # pad crop
-        if short_size < crop_size:
-            padh = crop_size - oh if oh < crop_size else 0
-            padw = crop_size - ow if ow < crop_size else 0
-            img  = ImageOps.expand(img,  border=(0,0,padw,padh), fill=0)
-            mask = ImageOps.expand(mask, border=(0,0,padw,padh), fill=0)
-        # random crop 480
-        w, h = img.size
-        x1 = random.randint(0, w - crop_size)
-        y1 = random.randint(0, h - crop_size) 
-        img = img.crop((x1, y1, x1+crop_size, y1+crop_size))
-        mask = mask.crop((x1, y1, x1+crop_size, y1+crop_size))
-        # gaussian blur as in PSP ?
-        if random.random() < 0.5:
-            img = img.filter(ImageFilter.GaussianBlur(
-                radius=random.random()))
-        return img, mask
-
-def get_city_pairs(folder, mode='train'):
-    img_paths = []  
-    mask_paths = []  
-    img_folder = os.path.join(folder, 'leftImg8bit/' + mode)
-    mask_folder = os.path.join(folder, 'gtFine/'+ mode)
-    for root, directories, files in os.walk(img_folder):
-        for filename in files:#os.listdir(img_folder):
-            #basename, extension =os.path.splitext(filename)
-            if filename.endswith(".png"):
-                imgpath = os.path.join(root, filename)
-                foldername = os.path.basename(os.path.dirname(imgpath))
-                maskname = filename.replace('leftImg8bit','gtFine_trainIds')
-                maskpath = os.path.join(mask_folder, foldername, maskname)
-                if os.path.isfile(imgpath) and os.path.isfile(maskpath):
-                    img_paths.append(imgpath)
-                    mask_paths.append(maskpath)
-                else:
-                    print('cannot find the mask or image:', imgpath, maskpath)
-
-    return img_paths, mask_paths

encoding/datasets/cityscapescoarse.py

-###########################################################################
-# Created by: Hang Zhang
-# Email: zhang.hang@rutgers.edu
-# Copyright (c) 2017
-###########################################################################
-
-import os
-import sys
-import numpy as np
-import random
-import math
-from tqdm import tqdm
-from PIL import Image, ImageOps, ImageFilter
-
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transform
-
-class Segmentation(data.Dataset):
-    BASE_DIR = 'cityscapes'
-    
-    def __init__(self, data_folder, mode='train', transform=None, 
-                 target_transform=None):
-        self.root = os.path.join(data_folder, self.BASE_DIR)
-        self.transform = transform
-        self.target_transform = target_transform
-        self.mode = mode
-        self.images, self.masks = get_city_pairs(self.root, mode)
-        assert (len(self.images) == len(self.masks))
-        if len(self.images) == 0:
-            raise(RuntimeError("Found 0 images in subfolders of: \
-                " + self.root + "\n"))
-
-    def __getitem__(self, index):
-        img = Image.open(self.images[index]).convert('RGB')
-        if self.mode == 'test':
-            if self.transform is not None:
-                img = self.transform(img)
-            return img, os.path.basename(self.images[index])
-
-        mask = Image.open(self.masks[index])#.convert("P")
-        mask = np.array(mask) 
-        mask += 1
-        mask[mask==256] = 0
-        mask = Image.fromarray(mask)
-        # synchrosized transform
-        if self.mode == 'train':
-            img, mask = self._sync_transform(img, mask)
-        elif self.mode == 'val':
-            img, mask = self._val_sync_transform(img, mask)
-        else:
-            raise RuntimeError('unknown mode for dataloader: {}'.format(self.mode))
-        
-
-        # general resize, normalize and toTensor
-        if self.transform is not None:
-            #print("transform for input")
-            img = self.transform(img)
-        if self.target_transform is not None:
-            #print("transform for label")
-            mask = self.target_transform(mask)
-
-        return img, mask
-
-    def __len__(self):
-        return len(self.images)
-
-    def _val_sync_transform(self, img, mask):
-        """
-        synchronized transformation
-        """
-        outsize = 720
-        short = outsize
-        w, h = img.size
-        if w > h:
-            oh = short
-            ow = int(1.0 * w * oh / h)
-        else:
-            ow = short
-            oh = int(1.0 * h * ow / w)
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # center crop
-        w, h = img.size
-        x1 = int(round((w - outsize) / 2.))
-        y1 = int(round((h - outsize) / 2.))
-        img = img.crop((x1, y1, x1+outsize, y1+outsize))
-        mask = mask.crop((x1, y1, x1+outsize, y1+outsize))
-
-        return img, mask
-
-    def _sync_transform(self, img, mask):
-        # random mirror
-        if random.random() < 0.5:
-            img  = img.transpose(Image.FLIP_LEFT_RIGHT)
-            mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
-        base_size = 2048
-        crop_size = 720
-        # random scale (short edge from 480 to 720)
-        long_size = random.randint(int(base_size*0.5), int(base_size*2.0))
-        w, h = img.size
-        if h > w:
-            oh = long_size
-            ow = int(1.0 * w * oh / h)
-            short_size = ow
-        else:
-            ow = long_size
-            oh = int(1.0 * h * ow / w)
-            short_size = oh
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # random rotate -10~10, mask using NN rotate
-        deg = random.uniform(-10,10)
-        img = img.rotate(deg, resample=Image.BILINEAR)
-        mask = mask.rotate(deg, resample=Image.NEAREST)
-        # pad crop
-        if short_size < crop_size:
-            padh = crop_size - oh if oh < crop_size else 0
-            padw = crop_size - ow if ow < crop_size else 0
-            img  = ImageOps.expand(img,  border=(0,0,padw,padh), fill=0)
-            mask = ImageOps.expand(mask, border=(0,0,padw,padh), fill=0)
-        # random crop 480
-        w, h = img.size
-        x1 = random.randint(0, w - crop_size)
-        y1 = random.randint(0, h - crop_size) 
-        img = img.crop((x1, y1, x1+crop_size, y1+crop_size))
-        mask = mask.crop((x1, y1, x1+crop_size, y1+crop_size))
-        # gaussian blur as in PSP ?
-        if random.random() < 0.5:
-            img = img.filter(ImageFilter.GaussianBlur(
-                radius=random.random()))
-        return img, mask
-
-
-def get_city_pairs(folder, mode='train'):
-    img_paths = []  
-    mask_paths = []  
-    if mode=='train':
-        img_folder = os.path.join(folder, 'leftImg8bit/train_extra')
-        mask_folder = os.path.join(folder, 'gtCoarse/train_extra')
-    else:
-        img_folder = os.path.join(folder, 'leftImg8bit/val')
-        mask_folder = os.path.join(folder, 'gtFine/val')
-    for root, directories, files in os.walk(img_folder):
-        for filename in files:
-            basename, extension =os.path.splitext(filename)
-            if filename.endswith(".png"):
-                imgpath = os.path.join(root, filename)
-                foldername = os.path.basename(os.path.dirname(imgpath))
-                maskname = filename.replace('leftImg8bit','gtCoarse_trainIds')
-                maskpath = os.path.join(mask_folder, foldername, maskname)
-                if os.path.isfile(imgpath) and os.path.isfile(maskpath):
-                    img_paths.append(imgpath)
-                    mask_paths.append(maskpath)
-                else:
-                    print('cannot find the mask or image:', imgpath, maskpath)
-
-    return img_paths, mask_paths

encoding/datasets/coco.py

-import os
-from tqdm import tqdm, trange
-from PIL import Image, ImageOps, ImageFilter
-
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transform
-import random
-import math
-import numpy as np
-
-from .dataset import ToLabel
-
-"""
-NUM_CHANNEL = 91
-[] background
-[5] airplane
-[2] bicycle
-[16] bird
-[9] boat
-[44] bottle
-[6] bus
-[3] car
-[17] cat
-[62] chair
-[21] cow
-[67] dining table
-[18] dog
-[19] horse
-[4] motorcycle
-[1] person
-[64] potted plant
-[20] sheep
-[63] couch
-[7] train
-[72] tv
-"""
-catlist = [0, 5, 2, 16, 9, 44, 6, 3, 17, 62, 21, 67, 18, 19, 4,
-    1, 64, 20, 63, 7, 72]
-
-
-class Segmentation(data.Dataset):
-    def __init__(self, root, mode='train', transform=None, 
-                 target_transform=None):
-        from pycocotools.coco import COCO
-        from pycocotools import mask
-        if mode == 'train':
-            print('train set')
-            ann_file = os.path.join(root, 'coco/annotations/instances_train2014.json')
-            ids_file = os.path.join(root, 'coco/annotations/train_ids.pth')
-            root = os.path.join(root, 'coco/train2014')
-        else:
-            print('val set')
-            ann_file = os.path.join(root, 'coco/annotations/instances_val2014.json')
-            ids_file = os.path.join(root, 'coco/annotations/val_ids.pth')
-            root = os.path.join(root, 'coco/val2014')
-        self.train = mode
-        self.root = root
-        self.coco = COCO(ann_file)
-        self.coco_mask = mask
-        if os.path.exists(ids_file):
-            self.ids = torch.load(ids_file)
-        else:
-            self.new_ids = []
-            self.ids = list(self.coco.imgs.keys())
-            self.preprocess(ids_file)
-            self.ids = self.new_ids
-        self.transform = transform
-        self.target_transform = target_transform
-
-    def preprocess(self, ids_file):
-        tbar = trange(len(self.ids))
-        for i in tbar:
-            img_id = self.ids[i]
-            cocotarget = self.coco.loadAnns(self.coco.getAnnIds(imgIds=img_id))
-            img_metadata = self.coco.loadImgs(img_id)[0]
-            mask = self._gen_seg_mask(cocotarget, img_metadata['height'], 
-                                      img_metadata['width'])
-            # more than 1k pixels
-            if (mask > 0).sum() > 1000:
-                self.new_ids.append(img_id)
-            tbar.set_description('Doing: {}/{}, got {} qualified images'.\
-                format(i, len(self.ids), len(self.new_ids)))
-
-        print('number of qualified images: ', len(self.new_ids))
-        torch.save(self.new_ids, ids_file)
-
-    def __getitem__(self, index):
-        coco = self.coco
-        img_id = self.ids[index]
-        cocotarget = coco.loadAnns(coco.getAnnIds(imgIds=img_id))
-        img_metadata = coco.loadImgs(img_id)[0]
-        path = img_metadata['file_name']
-
-        img = Image.open(os.path.join(self.root, path)).convert('RGB')
-        mask = Image.fromarray(
-            self._gen_seg_mask(cocotarget, img_metadata['height'], 
-                               img_metadata['width'])
-            )
-        # synchrosized transform
-        if True:#self.train == 'train':
-            img, mask = self._sync_transform(img, mask)
-        else:
-            img, mask = self._val_sync_transform(img, mask)
-
-        # general resize, normalize and toTensor
-        if self.transform is not None:
-            #print("transform for input")
-            img = self.transform(img)
-        if self.target_transform is not None:
-            #print("transform for label")
-            mask = self.target_transform(mask)
-
-        return img, mask
-
-    def __len__(self):
-        return len(self.ids)
-
-    def _val_sync_transform(self, img, mask):
-        outsize = 480
-        short = outsize
-        w, h = img.size
-        if w > h:
-            oh = short
-            ow = int(1.0 * w * oh / h)
-        else:
-            ow = short
-            oh = int(1.0 * h * ow / w)
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # center crop
-        w, h = img.size
-        x1 = int(round((w - outsize) / 2.))
-        y1 = int(round((h - outsize) / 2.))
-        img = img.crop((x1, y1, x1+outsize, y1+outsize))
-        mask = mask.crop((x1, y1, x1+outsize, y1+outsize))
-
-        return img, mask
-
-    def _sync_transform(self, img, mask):
-        # random mirror
-        if random.random() < 0.5:
-            img  = img.transpose(Image.FLIP_LEFT_RIGHT)
-            mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
-        base_size = 520
-        crop_size = 480
-        # random scale (short edge from 480 to 720)
-        long_size = random.randint(int(base_size*0.5), int(base_size*2.0))
-        w, h = img.size
-        if h > w:
-            oh = long_size
-            ow = int(1.0 * w * oh / h)
-            short_size = ow
-        else:
-            ow = long_size
-            oh = int(1.0 * h * ow / w)
-            short_size = oh
-        img = img.resize((ow, oh), Image.BILINEAR)
-        mask = mask.resize((ow, oh), Image.NEAREST)
-        # random rotate -10~10, mask using NN rotate
-        deg = random.uniform(-10,10)
-        img = img.rotate(deg, resample=Image.BILINEAR)
-        mask = mask.rotate(deg, resample=Image.NEAREST)
-        # pad crop
-        if short_size < crop_size:
-            padh = crop_size - oh if oh < crop_size else 0
-            padw = crop_size - ow if ow < crop_size else 0
-            img  = ImageOps.expand(img,  border=(0,0,padw,padh), fill=0)
-            mask = ImageOps.expand(mask, border=(0,0,padw,padh), fill=0)
-        # random crop 480
-        w, h = img.size
-        x1 = random.randint(0, w - crop_size)
-        y1 = random.randint(0, h - crop_size) 
-        img = img.crop((x1, y1, x1+crop_size, y1+crop_size))
-        mask = mask.crop((x1, y1, x1+crop_size, y1+crop_size))
-        # gaussian blur as in PSP ?
-        if random.random() < 0.5:
-            img = img.filter(ImageFilter.GaussianBlur(
-                radius=random.random()))
-        return img, mask
-
-    def _gen_seg_mask(self, target, h, w):
-        mask = np.zeros((h, w), dtype=np.uint8)
-        coco_mask = self.coco_mask
-        for instance in target:
-            rle = coco_mask.frPyObjects(instance['segmentation'], h, w)
-            m = coco_mask.decode(rle)
-            cat = instance['category_id']
-            if cat in catlist:
-                c = catlist.index(cat)
-            else:
-                continue
-            if len(m.shape) < 3:
-                mask[:, :] += (mask == 0) * (m * c)
-            else:
-                mask[:, :] += (mask == 0) * (((np.sum(m, axis=2)) > 0) * c).astype(np.uint8)
-        return mask

encoding/datasets/download_datasets.sh

-mkdir -p "$HOME"/data
-cd "$HOME"/data
-
-# augmented PASCAL VOC
-wget http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz # 1.3 GB
-tar -zxvf benchmark.tgz
-mv benchmark_RELEASE VOCaug
-<<<<<<< HEAD
-# generate trainval txt
-cd VOCaug/dataset/
-cp train.txt trainval.txt
-cat val.txt >> trainval.txt
-cd -
-
-=======
-
-# generate trainval.txt
-cd VOCaug/dataset/
-cp train.txt trainval.txt
-cat val.txt >>  trainval.txt
-
-cd "$HOME"/data
->>>>>>> d7e511b09ee6127be11f03497b7d83327e9f7b1b
-# original PASCAL VOC 2012
-wget http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar # 2 GB
-tar -xvf VOCtrainval_11-May-2012.tar
-
-<<<<<<< HEAD
-# for PASCAL VOC testset, you need to login and manually download from (http://host.robots.ox.ac.uk:8080/)
-=======
-cd -
->>>>>>> d7e511b09ee6127be11f03497b7d83327e9f7b1b

encoding/datasets/folder.py

-###########################################################################
-# Created by: Hang Zhang 
-# Email: zhang.hang@rutgers.edu 
-# Copyright (c) 2017
-###########################################################################
-
-import os
-import sys
-import numpy as np
-import random
-import math
-
-import torch.utils.data as data
-from PIL import Image, ImageOps
-
-import torch.utils.data as data
-import torchvision.transforms as transform
-from .dataset import ToLabel
-
-class FolderLoader(data.Dataset):
-    def __init__(self, root, transform=None):
-        self.root = root
-        self.transform = transform
-        self.images = get_folder_images(root)
-        if len(self.images) == 0:
-            raise(RuntimeError("Found 0 images in subfolders of: \
-                " + self.root + "\n"))
-
-    def __getitem__(self, index):
-        img = Image.open(self.images[index]).convert('RGB')
-        if self.transform is not None:
-            img = self.transform(img)
-        return img, os.path.basename(self.images[index])
-
-    def __len__(self):
-        return len(self.images)
-
-
-def get_folder_images(img_folder):
-    img_paths = []  
-    for filename in os.listdir(img_folder):
-        if filename.endswith(".jpg"):
-            imgpath = os.path.join(img_folder, filename)
-            img_paths.append(imgpath)
-    return img_paths
-
-
-
-class Dataloder():
-    def __init__(self, args):
-        # the data augmentation is implemented as part of the dataloader
-        assert(args.test)
-        input_transform = transform.Compose([
-            transform.ToTensor(),
-            transform.Normalize(args.mean, args.std)])
-        args.test_batch_size = 1 
-
-        assert(args.test_folder is not None)
-        print('loading the data from: {}'.format(args.test_folder))
-
-        testset = FolderLoader(args.test_folder, input_transform)
-        kwargs = {'num_workers': args.workers, 'pin_memory': True} \
-            if args.cuda else {}
-        self.trainloader = None
-        self.testloader = data.DataLoader(testset,
-                                     batch_size=args.test_batch_size,
-                                     shuffle=False, **kwargs)
-
-    def getloader(self):
-        return self.trainloader, self.testloader

encoding/datasets/hpw18.py

-# created by: Sean Liu
-# Amazon Lab 126
-from __future__ import print_function
-
-import errno
-import hashlib
-import os
-import sys
-import tarfile
-import numpy as np
-import random
-import math
-
-import torch.utils.data as data
-import PIL
-from PIL import Image, ImageOps
-
-from six.moves import urllib
-
-
-class Segmentation_HPW18(data.Dataset):
-    CLASSES = [
-        'background', 'hat', 'hair', 'sunglasses', 'upper-clothes', 
-        'skirt', 'pants', 'dress', 'belt', 'left-shoe', 'right-shoe', 
-        'face', 'left-leg', 'right-leg', 'left-arm', 'right-arm', 'bag', 
-        'scarf'
-    ]
-
-    URL = "/cvdata1/lliuqian/humanParsingDataset"
-    FILE = "hpw18.tar.gz"
-    MD5 = ''
-    BASE_DIR = ''
-
-    def __init__(self,
-                 root,
-                 train=True,
-                 transform=None,
-                 target_transform=None,
-                 download=False):
-        self.root = root
-        _hpw18_root = os.path.join(self.root, self.BASE_DIR)
-        _mask_dir = os.path.join(_hpw18_root, 'SegmentationClassAug_256x384')
-        _image_dir = os.path.join(_hpw18_root, 'JPEGImages_256x384')
-        self.transform = transform
-        self.target_transform = target_transform
-        self.train = train
-
-        if download:
-            self._download()
-
-        # train/val/test splits are pre-cut
-        _splits_dir = _hpw18_root
-        _split_f = os.path.join(_splits_dir, 'humanparsingImageMask_256x384_absPath_train.txt')
-        if not self.train:
-            _split_f = os.path.join(_splits_dir, 'humanparsingImageMask_256x384_absPath_val.txt')
-
-        print("reading from ", _split_f)
-
-        self.images = []
-        self.masks = []
-        with open(os.path.join(_split_f), "r") as lines:
-            for line in lines:
-                s = line.split()
-                _image = s[0] # image absolution path
-                _mask = s[1] # mask absolution path
-                assert os.path.isfile(_image)
-                assert os.path.isfile(_mask)
-                self.images.append(_image)
-                self.masks.append(_mask)
-        assert (len(self.images) == len(self.masks))
-
-    def __getitem__(self, index):
-        _img = Image.open(self.images[index]).convert('RGB')
-        _timg = Image.open(self.masks[index])
-        _target = np.array(_timg, dtype=np.uint8)
-        _target = Image.fromarray(_target)
-
-        # synchrosized transform
-        if self.train:
-            _img, _target = self._sync_transform( _img, _target)
-
-        # general resize, normalize and toTensor
-        if self.transform is not None:
-            _img = self.transform(_img)
-        if self.target_transform is not None:
-            _target = self.target_transform(_target)
-
-        return _img, _target
-
-    def __len__(self):
-        return len(self.images)
-
-    def _sync_transform(self, img, mask):
-        # random rotate -10~10
-        deg = random.uniform(-10,10)
-        img = img.rotate(deg)
-        mask = mask.rotate(deg, PIL.Image.NEAREST)
-
-        return img, mask
-
-if __name__ == '__main__':
-    hpw18 = Segmentation_HPW18('/cvdata1/lliuqian/', train=True)
-    print(hpw18[0])
-    print (len(hpw18))