def test_display_all_details(self):
'''
method that returns a list of all details saved
'''
self.assertEqual(Detail.display_details(), Detail.detail_list)
class PASCALContext(data.Dataset):
def __init__(self,
cfg,
root,
image_set,
num_classes=59,
transform=None,
augmentations=None):
self.cfg = cfg
self.root = os.path.join(root, 'VOCdevkit/VOC2010')
# self.root = root
self.image_set = image_set
if 'xception' in cfg.MODEL.NAME:
mean = np.array([0.5, 0.5, 0.5], dtype=np.float32)
std = np.array([0.5, 0.5, 0.5], dtype=np.float32)
else:
mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
self.mean = np.expand_dims(np.expand_dims(np.expand_dims(mean, axis=0),
axis=-1),
axis=-1)
self.std = np.expand_dims(np.expand_dims(np.expand_dims(std, axis=0),
axis=-1),
axis=-1)
self.patch_width = cfg.MODEL.IMAGE_SIZE[0]
self.patch_height = cfg.MODEL.IMAGE_SIZE[1]
self.n_classes = num_classes
self.output_stride = cfg.MODEL.OUTPUT_STRIDE
self.tf = transform
self.augmentations = augmentations
self._setup_db()
self.db_length = len(self.files)
def __len__(self):
return len(self.files)
def __getitem__(self, index):
item = self.files[index]
im_name = item['file_name']
im_path = os.path.join(self.root, "JPEGImages", im_name)
img_id = item['image_id']
im = Image.open(im_path)
lbl = np.asarray(self.masks[img_id], dtype=np.int)
lbl = self.label_transform(lbl)
# Map all ignored pixels to class index 255
lbl[np.logical_or(lbl >= self.n_classes, lbl < 0)] = 255
lbl = Image.fromarray(lbl)
if self.augmentations is not None:
im, lbl = self.augmentations(im, lbl)
im, lbl, lbl_os = self.transform(im, lbl)
if self.cfg.MODEL.LEARN_PAIRWISE_TERMS:
# if self.cfg.MODEL.NUM_PAIRWISE_TERMS > 1:
lbl_hs = []
lbl_vs = []
stride = 1
for _ in range(self.cfg.MODEL.NUM_PAIRWISE_TERMS):
for i in range(stride):
for j in range(stride):
lbl_os_ = lbl_os[i::stride, j::stride]
lbl_h = lbl_os_[:, :-1] * self.n_classes + lbl_os_[:,
1:]
lbl_v = lbl_os_[:-1, :] * self.n_classes + lbl_os_[
1:, :]
lbl_h[(lbl_os_[:, :-1] >= self.n_classes) |
(lbl_os_[:, 1:] >= self.n_classes)] = 255
lbl_v[(lbl_os_[:-1, :] >= self.n_classes) |
(lbl_os_[1:, :] >= self.n_classes)] = 255
lbl_hs.append(lbl_h)
lbl_vs.append(lbl_v)
stride += self.cfg.MODEL.PAIRWISE_STEP_SIZE
# else:
# lbl_h = lbl_os[:, :-1] * self.n_classes + lbl_os[:, 1:]
# lbl_v = lbl_os[:-1, :] * self.n_classes + lbl_os[1:, :]
# lbl_h[(lbl_os[:, :-1] >= self.n_classes) | (lbl_os[:, 1:] >= self.n_classes)] = 255
# lbl_v[(lbl_os[:-1, :] >= self.n_classes) | (lbl_os[1:, :] >= self.n_classes)] = 255
return im, lbl, lbl_hs, lbl_vs, dict()
else:
return im, lbl, dict(), dict(), dict()
def transform(self, img, lbl):
if self.tf is not None:
img = self.tf(img)
# if self.is_train:
w, h = lbl.size
lbl_os = lbl.resize((math.ceil(
w / self.output_stride), math.ceil(h / self.output_stride)),
Image.NEAREST)
lbl = torch.from_numpy(np.array(lbl)).long()
lbl[lbl >= self.n_classes] = 255 # ignore pixels
lbl_os = torch.from_numpy(np.array(lbl_os)).long()
lbl_os[lbl_os >= self.n_classes] = 255 # ignore pixels
return img, lbl, lbl_os
def _setup_db(self):
# prepare data
annots = os.path.join(self.root, 'trainval_merged.json')
img_path = os.path.join(self.root, 'JPEGImages')
from detail import Detail
if 'val' in self.image_set:
self.detail = Detail(annots, img_path, 'val')
mask_file = os.path.join(self.root, 'val.pth')
elif 'train' in self.image_set:
self.mode = 'train'
self.detail = Detail(annots, img_path, 'train')
mask_file = os.path.join(self.root, 'train.pth')
else:
raise NotImplementedError('only supporting train and val set.')
self.files = self.detail.getImgs()
# generate masks
self._mapping = np.sort(
np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25,
284, 158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45,
46, 308, 59, 440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458,
34, 207, 80, 355, 85, 347, 220, 349, 360, 98, 187, 104, 105,
366, 189, 368, 113, 115
]))
self._key = np.array(range(len(self._mapping))).astype('uint8')
print('mask_file:', mask_file)
if os.path.exists(mask_file):
self.masks = torch.load(mask_file)
else:
self.masks = self._preprocess(mask_file)
def decode_segmap(self, label_mask, plot=False):
"""Decode segmentation class labels into a color image
Args:
label_mask (np.ndarray): an (M,N) array of integer values denoting
the class label at each spatial location.
plot (bool, optional): whether to show the resulting color image
in a figure.
Returns:
(np.ndarray, optional): the resulting decoded color image.
"""
label_colours = self.get_pascal_labels()
r = label_mask.copy()
g = label_mask.copy()
b = label_mask.copy()
for ll in range(0, self.n_classes):
r[label_mask == ll] = label_colours[ll, 0]
g[label_mask == ll] = label_colours[ll, 1]
b[label_mask == ll] = label_colours[ll, 2]
rgb = np.zeros((label_mask.shape[0], label_mask.shape[1], 3))
rgb[:, :, 0] = r / 255.0
rgb[:, :, 1] = g / 255.0
rgb[:, :, 2] = b / 255.0
if plot:
plt.imshow(rgb)
plt.show()
else:
return rgb
def _class_to_index(self, mask):
# assert the values
values = np.unique(mask)
for i in range(len(values)):
assert (values[i] in self._mapping)
index = np.digitize(mask.ravel(), self._mapping, right=True)
return self._key[index].reshape(mask.shape)
def _preprocess(self, mask_file):
masks = {}
print("Preprocessing mask, this will take a while." + \
"But don't worry, it only run once for each split.")
for i in range(len(self.files)):
img_id = self.files[i]
mask = Image.fromarray(
self._class_to_index(self.detail.getMask(img_id)))
masks[img_id['image_id']] = mask
torch.save(masks, mask_file)
return masks
def label_transform(self, label):
if self.n_classes == 59:
# background is ignored
label = np.array(label).astype('int32') - 1
label[label == -2] = -1
else:
label = np.array(label).astype('int32')
return label
def get_pascal_labels(self):
"""Load the mapping that associates pascal-context classes with label colors
Returns:
np.ndarray with dimensions (60, 3)
"""
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, self.n_classes - 1)]
colors = np.array([[c[2] * 255, c[1] * 255, c[0] * 255]
for c in colors])
colors = np.vstack(([[0, 0, 0]], colors))
return colors
class PASCALContext(BaseDataset):
def __init__(self,
root,
list_path,
num_samples=None,
num_classes=59,
multi_scale=True,
flip=True,
ignore_label=-1,
base_size=520,
crop_size=(480, 480),
downsample_rate=1,
scale_factor=16,
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],):
super(PASCALContext, self).__init__(ignore_label, base_size,
crop_size, downsample_rate, scale_factor, mean, std)
self.root = os.path.join(root, 'pascal_ctx/VOCdevkit/VOC2010')
self.split = list_path
self.num_classes = num_classes
self.class_weights = None
self.multi_scale = multi_scale
self.flip = flip
self.crop_size = crop_size
# prepare data
annots = os.path.join(self.root, 'trainval_merged.json')
img_path = os.path.join(self.root, 'JPEGImages')
from detail import Detail
if 'val' in self.split:
self.detail = Detail(annots, img_path, 'val')
mask_file = os.path.join(self.root, 'val.pth')
elif 'train' in self.split:
self.mode = 'train'
self.detail = Detail(annots, img_path, 'train')
mask_file = os.path.join(self.root, 'train.pth')
else:
raise NotImplementedError('only supporting train and val set.')
self.files = self.detail.getImgs()
# generate masks
self._mapping = np.sort(np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22,
23, 397, 25, 284, 158, 159, 416, 33, 162, 420, 454, 295, 296,
427, 44, 45, 46, 308, 59, 440, 445, 31, 232, 65, 354, 424,
68, 326, 72, 458, 34, 207, 80, 355, 85, 347, 220, 349, 360,
98, 187, 104, 105, 366, 189, 368, 113, 115]))
self._key = np.array(range(len(self._mapping))).astype('uint8')
print('mask_file:', mask_file)
if os.path.exists(mask_file):
self.masks = torch.load(mask_file)
else:
self.masks = self._preprocess(mask_file)
def _class_to_index(self, mask):
# assert the values
values = np.unique(mask)
for i in range(len(values)):
assert(values[i] in self._mapping)
index = np.digitize(mask.ravel(), self._mapping, right=True)
return self._key[index].reshape(mask.shape)
def _preprocess(self, mask_file):
masks = {}
print("Preprocessing mask, this will take a while." + \
"But don't worry, it only run once for each split.")
for i in range(len(self.files)):
img_id = self.files[i]
mask = Image.fromarray(self._class_to_index(
self.detail.getMask(img_id)))
masks[img_id['image_id']] = mask
torch.save(masks, mask_file)
return masks
def __getitem__(self, index):
item = self.files[index]
name = item['file_name']
img_id = item['image_id']
image = cv2.imread(os.path.join(self.detail.img_folder,name),
cv2.IMREAD_COLOR)
label = np.asarray(self.masks[img_id],dtype=np.int)
size = image.shape
if self.split == 'val':
image = cv2.resize(image, self.crop_size,
interpolation = cv2.INTER_LINEAR)
image = self.input_transform(image)
image = image.transpose((2, 0, 1))
label = cv2.resize(label, self.crop_size,
interpolation=cv2.INTER_NEAREST)
label = self.label_transform(label)
elif self.split == 'testval':
# evaluate model on val dataset
image = self.input_transform(image)
image = image.transpose((2, 0, 1))
label = self.label_transform(label)
else:
image, label = self.gen_sample(image, label,
self.multi_scale, self.flip)
return image.copy(), label.copy(), np.array(size), name
def label_transform(self, label):
if self.num_classes == 59:
# background is ignored
label = np.array(label).astype('int32') - 1
label[label==-2] = -1
else:
label = np.array(label).astype('int32')
return label
class TestDetail(unittest.TestCase):
# import pyperclip
'''
Test class that defines test cases for the detail class behaviours.
Args:
unittest.TestCase: TestCase class that helps in creating test cases
'''
# Items up here .......
def setUp(self):
'''
Set up method to run before each test cases.
'''
self.new_detail = Detail(
"xyz", "xyz", "2222222222", "*****@*****.**") # create detail object
def test_init(self):
'''
test_init test case to test if the object is initialized properly
'''
self.assertEqual(self.new_detail.user_name, "xyz")
self.assertEqual(self.new_detail.user_name, "xyz")
self.assertEqual(self.new_detail.account_password, "2222222222")
self.assertEqual(self.new_detail.email, "*****@*****.**")
def test_save_detail(self):
'''
test_save_detail test case to test if the detail object is saved into
the detail list
'''
self.new_detail.save_detail() # saving the new detail
self.assertEqual(len(Detail.detail_list), 1)
def test_find_detail_by_password(self):
'''
test to check if we can find a detail by account password and display information
'''
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "2222222222",
"*****@*****.**") # new detail
test_detail.save_detail()
found_detail = Detail.find_by_password("2222222222")
self.assertEqual(found_detail.email, test_detail.email)
def test_detail_exists(self):
'''
test to check if we can return a Boolean if we cannot find the detail.
'''
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "2222222222",
"*****@*****.**") # new detail
test_detail.save_detail()
detail_exists = Detail.detail_exist("2222222222")
self.assertTrue(detail_exists)
def test_display_all_details(self):
'''
method that returns a list of all details saved
'''
self.assertEqual(Detail.display_details(), Detail.detail_list)
def test_copy_email(self):
'''
Test to confirm that we are copying the email address from a found detail
'''
self.new_detail.save_detail()
Detail.copy_email("2222222222")
self.assertEqual(self.new_detail.email, pyperclip.paste())
def find_detail(password):
"""
Function that finds a detail by password and returns the detail
"""
return Detail.find_by_password(password)
def display_details():
"""
Func that rteturns all the saved details
"""
return Detail.display_details()
class DetailDataset(torch.utils.data.Dataset):
CLASSES = PascalVOCDataset.CLASSES # TODO to chyba nie wszystkie, Detail.getCats() zwraca wiecej
def __init__(self,
img_dir,
ann_file,
split,
minimal=False,
transforms=None):
self.img_dir = img_dir
self.image_set = split
self.transforms = transforms
self.anno = ann_file
self.detail = Detail(ann_file, img_dir, split, minimal, divider=10)
# TODO poprawny format klas:
self.CLASSES = self.detail.getCats()
imgs = self.detail.getImgs()
idxs = range(len(imgs))
self.idx_to_img = dict(zip(idxs, imgs))
# TODO może się przydać, zrobic to poprawnie, uważając na underscore
# self.img_to_idx = dict(zip([x.image_id for x in imgs], idxs))
self.class_to_ind = dict(zip(self.CLASSES, range(len(self.CLASSES))))
def __len__(self):
return len(self.idx_to_img)
def _img_size(self, img):
return (img['width'], img['height'])
def get_groundtruth(self, idx):
img = self.idx_to_img[idx]
boxes = self.detail.getBboxes(img)
# example of 'boxes':
# [{'bbox': [250, 209, 241, 149], 'category': 'motorbike'},
# {'bbox': [312, 139, 109, 191], 'category': 'person'}]
boxes = [box['bbox'] for box in boxes
] # TODO gubimy informację o otoczonym przedmiocie
boxes = torch.as_tensor(boxes).reshape(-1, 4) # guard against no boxes
target = BoxList(boxes, self._img_size(img),
mode="xywh").convert("xyxy")
target = target.clip_to_image(remove_empty=True)
img_keypoints = self.detail.getKpts(img)
keypoints = [skelton['keypoints'] for skelton in img_keypoints]
# TODO keypoints - gubimy informację o bbox
target.add_field("kpts", Keypoints(keypoints, self._img_size(img)))
# target.add_field("mask", SegmentationMask(self.detail.getMask(img).tolist(), size=self._img_size(img)))
# TODO getMask zwraca macierz rozmiaru (img.height, img.width), gdzie każdemu pikselowi
# TODO odpowiada numer id klasy, do której należy. SegmentationMask
# from getMask() doc:
# If semantic segmentation of an image is requested (cat=instance=superpart=part=None),
# the result is an image whose pixel values are the class IDs for that image.
# If instance-level segmentation for one category of an image is requested (img and cat provided),
# the result is an image whose pixel values are the instance IDs for that class and 0 everywhere else.
target.add_field("class_mask", self.detail.getMask(img))
target.add_field("instance_mask", self.detail.getMask(img,
cat='person'))
target.add_field("bounds", self.detail.getBounds(img))
target.add_field("occl", self.detail.getOccl(img))
# TODO human parts?
return target
def __getitem__(self, idx):
img = self.idx_to_img[idx]
# example img object:
# {'file_name': '2008_000002.jpg', 'phase': 'val', 'height': 375, 'width': 500,
# 'date_captured': '31-May-2015 17:44:04', 'image_id': 2008000002, 'annotations': [1, 62295],
# 'categories': [454, 427], 'parts': [16], 'keypoints': []}
img = Image.open(os.path.join(self.img_dir,
img['file_name'])).convert('RGB')
target = self.get_groundtruth(idx)
if self.transforms is not None:
img, target = self.transforms(img, target)
return img, target, idx
def get_img_info(self, idx):
img = self.idx_to_img[idx]
return {"height": img['height'], "width": img['width']}
if not os.path.isdir(submit_dir):
print(str(submit_dir) + " doesn't exist")
if os.path.isdir(submit_dir) and os.path.isdir(truth_dir):
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# output file
output_filename = os.path.join(output_dir, 'scores.txt')
output_file = open(output_filename, 'wb')
# trainval file
truth_file = os.path.join(truth_dir, "truth.json")
details = Detail(truth_file, '', 'trainval')
kpteval = detaileval_kpt.DetailEvalKpt(details)
# submission file, change filename for different results
submission_answer_file = os.path.join(submit_dir, "kpts_answer.json")
with open(submission_answer_file) as f:
data = json.load(f)['pred']
kpteval.loadRes(data)
print('*assembled*')
kpteval.evaluate()
print('*evaluated*')
kpteval.accumulate()
print('*accumulated*')
from operation import Operation
from detail import Detail
from algorithms import ghant
task_times = {1: [2, 3, 1], 2: [3, 2, 1], 3: [4, 1, 2], 4: [1, 2, 3]}
details = []
operations = []
for key, value in task_times.items():
details.append(Detail(key, value))
for i in range(len(task_times.get(1))):
operations.append(Operation())
for detail in details:
ghant(detail, operations)
for operation in operations:
print(operation)
class ContextSegmentation(BaseDataset):
BASE_DIR = 'VOCdevkit/VOC2010'
NUM_CLASS = 59
def __init__(self,
root=os.path.expanduser('~/.encoding/data'),
split='train',
mode=None,
transform=None,
target_transform=None):
super(ContextSegmentation, self).__init__(root, split, mode, transform,
target_transform)
from detail import Detail
#from detail import mask
root = os.path.join(root, self.BASE_DIR)
annFile = os.path.join(root, 'trainval_merged.json')
imgDir = os.path.join(root, 'JPEGImages')
# training mode
if split == 'train':
phase = 'train'
elif split == 'val':
phase = 'val'
elif split == 'test':
phase = 'val'
#phase = 'test'
print('annFile', annFile)
print('imgDir', imgDir)
self.detail = Detail(annFile, imgDir, phase)
self.transform = transform
self.target_transform = target_transform
self.ids = self.detail.getImgs()
self._mapping = np.sort(
np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25,
284, 158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45,
46, 308, 59, 440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458,
34, 207, 80, 355, 85, 347, 220, 349, 360, 98, 187, 104, 105,
366, 189, 368, 113, 115
]))
self._key = np.array(range(len(self._mapping))).astype('uint8')
def _class_to_index(self, mask):
# assert the values
values = np.unique(mask)
#assert(values.size > 1)
for i in range(len(values)):
assert (values[i] in self._mapping)
index = np.digitize(mask.ravel(), self._mapping, right=True)
return self._key[index].reshape(mask.shape)
def __getitem__(self, index):
detail = self.detail
img_id = self.ids[index]
path = img_id['file_name']
iid = img_id['image_id']
img = Image.open(os.path.join(detail.img_folder, path)).convert('RGB')
if self.mode == 'test':
if self.transform is not None:
img = self.transform(img)
return img, os.path.basename(path)
# convert mask to 60 categories
mask = Image.fromarray(self._class_to_index(detail.getMask(img_id)))
# 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:
assert self.mode == 'testval'
mask = self._mask_transform(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 _mask_transform(self, mask):
target = np.array(mask).astype('int32') - 1
return torch.from_numpy(target).long()
def __len__(self):
return len(self.ids)
@property
def pred_offset(self):
return 1
class TestDetail(unittest.TestCase):
# import pyperclip
'''
Test class that defines test cases for the detail class behaviours.
Args:
unittest.TestCase: TestCase class that helps in creating test cases
'''
# Items up here .......
def setUp(self):
'''
Set up method to run before each test cases.
'''
self.new_detail = Detail("xyz", "xyz", "2222222222",
"*****@*****.**") # create detail object
def test_init(self):
'''
test_init test case to test if the object is initialized properly
'''
self.assertEqual(self.new_detail.user_name, "xyz")
self.assertEqual(self.new_detail.user_name, "xyz")
self.assertEqual(self.new_detail.account_password, "2222222222")
self.assertEqual(self.new_detail.email, "*****@*****.**")
def test_save_detail(self):
'''
test_save_detail test case to test if the detail object is saved into
the detail list
'''
self.new_detail.save_detail() # saving the new detail
self.assertEqual(len(Detail.detail_list), 1)
# def test_sum():
# assert sum([1, 2, 3]) == 6, "Should be 6"
#
# test_sum()
# print("Everything passed")
# def test_save_multiple_detail(self):
# '''
# test_save_multiple_detail to check if we can save multiple detail
# objects to our detail_list
# '''
# self.new_detail.save_detail()
# test_detail = Detail(
# "Test", "user", "2222222222", "*****@*****.**") # new detail
# test_detail.save_detail()
# self.assertEqual(len(Detail.detail_list), 2)
# Items up here...
# def test_save_multiple_detail(self):
# '''
# test_save_multiple_detail to check if we can save multiple detail
# objects to our detail_list
# '''
# self.new_detail.save_detail()
# test_detail = Detail(
# "Test", "user", "2222222222", "*****@*****.**") # new detail
# test_detail.save_detail()
# self.assertEqual(len(Detail.detail_list), 2)
# setup and class creation up HERE
def tearDown(self):
"""
tearDown method that does clean up after each test case has runs
"""
Detail.detail_list = []
# Other test cases HERE
def test_save_multiple_detail(self):
"""
test_save_multiple_detail to check if we can save multiple detail objects
"""
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "2222222222",
"*****@*****.**") # new detail_list
test_detail.save_detail()
self.assertEqual(len(Detail.detail_list), 2)
# More tests above
def test_delete_detail(self):
'''
test_delete_detail to test if we can remove a detail from our detail list
'''
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "22222222222",
"*****@*****.**") # new detail
test_detail.save_detail()
self.new_detail.delete_detail() # Deleting a detail object
self.assertEqual(len(Detail.detail_list), 1)
def test_find_detail_by_password(self):
'''
test to check if we can find a detail by account password and display information
'''
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "2222222222",
"*****@*****.**") # new detail
test_detail.save_detail()
found_detail = Detail.find_by_password("2222222222")
self.assertEqual(found_detail.email, test_detail.email)
def test_detail_exists(self):
'''
test to check if we can return a Boolean if we cannot find the detail.
'''
self.new_detail.save_detail()
test_detail = Detail("Test", "user", "2222222222",
"*****@*****.**") # new detail
test_detail.save_detail()
detail_exists = Detail.detail_exist("2222222222")
self.assertTrue(detail_exists)
def test_display_all_details(self):
'''
method that returns a list of all details saved
'''
self.assertEqual(Detail.display_details(), Detail.detail_list)
def test_copy_email(self):
'''
Test to confirm that we are copying the email address from a found detail
'''
self.new_detail.save_detail()
Detail.copy_email("2222222222")
self.assertEqual(self.new_detail.email, pyperclip.paste())
def get(self): # Creates detail object detail = Detail() # Instantiate first bill table_1 = RestaurantBill() # Assign class's attributes table_1.tableNumber = 'Table 1' table_1.plate1 = 7.52 table_1.plate2 = 3.67 table_1.plate3 = 6.53 table_1.plate4 = 8.96 table_1.plate5 = 6.78 # Instantiate second bill table_2 = RestaurantBill() # Assign class's attributes table_2.tableNumber = 'Table 2' table_2.plate1 = 8.95 table_2.plate2 = 5.83 table_2.plate3 = 3.99 table_2.plate4 = 12.52 table_2.plate5 = 14.78 # Instantiate third bill table_3 = RestaurantBill() # Assign class's attributes table_3.tableNumber = 'Table 3' table_3.plate1 = 3.75 table_3.plate2 = 7.82 table_3.plate3 = 6.53 table_3.plate4 = 19.23 table_3.plate5 = 5.95 # Instantiate fourth bill table_4 = RestaurantBill() # Assign class's attributes table_4.tableNumber = 'Table 4' table_4.plate1 = 2.52 table_4.plate2 = 6.66 table_4.plate3 = 10.35 table_4.plate4 = 7.88 table_4.plate5 = 4.81 # Instantiate fifth bill table_5 = RestaurantBill() # Assign class's attributes table_5.tableNumber = 'Table 5' table_5.plate1 = 13.42 table_5.plate2 = 12.73 table_5.plate3 = 8.74 table_5.plate4 = 9.99 table_5.plate5 = 9.87 # Array to print out links bills = [table_1,table_2,table_3,table_4,table_5] # Shows the header html self.response.write(detail.header()) # Shows the form html self.response.write(detail.form()) # If statment to populate links if self.request.GET: bill = (int(self.request.GET['bill']))-1 self.response.write(self.html(bills[bill])) # Shows the footer html self.response.write(detail.footer())
class PascalContextGenerator(object):
def __init__(self, voc_path, annotation_path):
self.voc_path = voc_path
self.annotation_path = annotation_path
self.label_dir = os.path.join(self.voc_path, 'Context')
self._image_dir = os.path.join(self.voc_path, 'JPEGImages')
self.annFile = os.path.join(self.annotation_path,
'trainval_merged.json')
if not os.path.exists(self.annFile):
_download_file(url=JSON_URL,
savepath=self.annotation_path,
print_progress=True)
self._mapping = np.sort(
np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25,
284, 158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45,
46, 308, 59, 440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458,
34, 207, 80, 355, 85, 347, 220, 349, 360, 98, 187, 104, 105,
366, 189, 368, 113, 115
]))
self._key = np.array(range(len(self._mapping))).astype('uint8') - 1
self.train_detail = Detail(self.annFile, self._image_dir, 'train')
self.train_ids = self.train_detail.getImgs()
self.val_detail = Detail(self.annFile, self._image_dir, 'val')
self.val_ids = self.val_detail.getImgs()
if not os.path.exists(self.label_dir):
os.makedirs(self.label_dir)
def _class_to_index(self, mask, _mapping, _key):
# assert the values
values = np.unique(mask)
for i in range(len(values)):
assert (values[i] in _mapping)
index = np.digitize(mask.ravel(), _mapping, right=True)
return _key[index].reshape(mask.shape)
def save_mask(self, img_id, mode):
if mode == 'train':
mask = Image.fromarray(
self._class_to_index(self.train_detail.getMask(img_id),
_mapping=self._mapping,
_key=self._key))
elif mode == 'val':
mask = Image.fromarray(
self._class_to_index(self.val_detail.getMask(img_id),
_mapping=self._mapping,
_key=self._key))
filename = img_id['file_name']
basename, _ = os.path.splitext(filename)
if filename.endswith(".jpg"):
mask_png_name = basename + '.png'
mask.save(os.path.join(self.label_dir, mask_png_name))
return basename
def generate_label(self):
with open(
os.path.join(self.voc_path,
'ImageSets/Segmentation/train_context.txt'),
'w') as f:
for img_id in tqdm.tqdm(self.train_ids, desc='train'):
basename = self.save_mask(img_id, 'train')
f.writelines(''.join([basename, '\n']))
with open(
os.path.join(self.voc_path,
'ImageSets/Segmentation/val_context.txt'),
'w') as f:
for img_id in tqdm.tqdm(self.val_ids, desc='val'):
basename = self.save_mask(img_id, 'val')
f.writelines(''.join([basename, '\n']))
with open(
os.path.join(self.voc_path,
'ImageSets/Segmentation/trainval_context.txt'),
'w') as f:
for img in tqdm.tqdm(os.listdir(self.label_dir), desc='trainval'):
if img.endswith('.png'):
basename = img.split('.', 1)[0]
f.writelines(''.join([basename, '\n']))
class ContextSegmentation(BaseDataset):
BASE_DIR = 'pcontext/VOCdevkit/VOC2010'
NUM_CLASS = 60
def __init__(self, root=os.path.expanduser('../datasets'), split='train',
mode=None, transform=None, target_transform=None, **kwargs):
super(ContextSegmentation, self).__init__(
root, split, mode, transform, target_transform, **kwargs)
from detail import Detail
#from detail import mask
root = os.path.join(root, self.BASE_DIR)
annFile = os.path.join(root, 'trainval_merged.json')
imgDir = os.path.join(root, 'JPEGImages')
mask_file = os.path.join(root, self.split+'.pth')
# training mode
self.detail = Detail(annFile, imgDir, split)
self.transform = transform
self.target_transform = target_transform
self.ids = self.detail.getImgs()
# generate masks
self._mapping = np.sort(np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22,
23, 397, 25, 284, 158, 159, 416, 33, 162, 420, 454, 295, 296,
427, 44, 45, 46, 308, 59, 440, 445, 31, 232, 65, 354, 424,
68, 326, 72, 458, 34, 207, 80, 355, 85, 347, 220, 349, 360,
98, 187, 104, 105, 366, 189, 368, 113, 115]))
self._key = np.array(range(len(self._mapping))).astype('uint8')
if os.path.exists(mask_file):
self.masks = torch.load(mask_file)
else:
self.masks = self._preprocess(mask_file)
def _class_to_index(self, mask):
# assert the values
values = np.unique(mask)
#assert(values.size > 1)
for i in range(len(values)):
assert(values[i] in self._mapping)
index = np.digitize(mask.ravel(), self._mapping, right=True)
return self._key[index].reshape(mask.shape)
def _preprocess(self, mask_file):
masks = {}
tbar = trange(len(self.ids))
print("Preprocessing mask, this will take a while." + \
"But don't worry, it only run once for each split.")
for i in tbar:
img_id = self.ids[i]
mask = Image.fromarray(self._class_to_index(
self.detail.getMask(img_id)))
masks[img_id['image_id']] = mask
tbar.set_description("Preprocessing masks {}".format(img_id['image_id']))
torch.save(masks, mask_file)
return masks
def __getitem__(self, index):
img_id = self.ids[index]
path = img_id['file_name']
iid = img_id['image_id']
img = Image.open(os.path.join(self.detail.img_folder, path)).convert('RGB')
if self.mode == 'test':
if self.transform is not None:
img = self.transform(img)
return img, os.path.basename(path)
# convert mask to 60 categories
mask = self.masks[iid]
# 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:
assert self.mode == 'testval'
mask = self._mask_transform(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 _mask_transform(self, mask):
target = np.array(mask).astype('int32') - 1
return torch.from_numpy(target).long()
def __len__(self):
return len(self.ids)
@property
def pred_offset(self):
return 1
class PascalContext(BaseDataset):
NUM_CLASS = 59
def __init__(self,
root='./data',
split='train',
mode=None,
transform=None,
target_transform=None,
**kwargs):
super(PascalContext, self).__init__(root, split, mode, transform,
target_transform, **kwargs)
from detail import Detail
#from detail import mask
root = os.path.join(root, 'PascalContext')
annFile = os.path.join(root, 'trainval_merged.json')
imgDir = os.path.join(root, 'JPEGImages')
# training mode
self.detail = Detail(annFile, imgDir, split)
self.transform = transform
self.target_transform = target_transform
self.ids = self.detail.getImgs()
# generate masks
self._mapping = np.sort(
np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25,
284, 158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45,
46, 308, 59, 440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458,
34, 207, 80, 355, 85, 347, 220, 349, 360, 98, 187, 104, 105,
366, 189, 368, 113, 115
]))
self.classes = [
'background', 'aeroplane', 'mountain', 'mouse', 'track', 'road',
'bag', 'motorbike', 'fence', 'bed', 'bedclothes', 'bench',
'bicycle', 'diningtable', 'bird', 'person', 'floor', 'boat',
'train', 'book', 'bottle', 'tree', 'window', 'plate', 'platform',
'tvmonitor', 'building', 'bus', 'cabinet', 'shelves', 'light',
'pottedplant', 'wall', 'car', 'ground', 'cat', 'sidewalk', 'truck',
'ceiling', 'rock', 'chair', 'wood', 'food', 'horse', 'cloth',
'sign', 'computer', 'sheep', 'keyboard', 'flower', 'sky', 'cow',
'grass', 'cup', 'curtain', 'snow', 'water', 'sofa', 'dog', 'door'
]
self._key = np.array(range(len(self._mapping))).astype('uint8')
mask_file = os.path.join(root, self.split + '.pth')
print('mask_file:', mask_file)
if os.path.exists(mask_file):
self.masks = torch.load(mask_file)
else:
self.masks = self._preprocess(mask_file)
def _class_to_index(self, mask):
# assert the values
values = np.unique(mask)
for i in range(len(values)):
assert (values[i] in self._mapping)
index = np.digitize(mask.ravel(), self._mapping, right=True)
return self._key[index].reshape(mask.shape)
def _preprocess(self, mask_file):
masks = {}
tbar = trange(len(self.ids))
print("Preprocessing mask, this will take a while." + \
"But don't worry, it only run once for each split.")
for i in tbar:
img_id = self.ids[i]
mask = Image.fromarray(
self._class_to_index(self.detail.getMask(img_id)))
masks[img_id['image_id']] = mask
tbar.set_description("Preprocessing masks {}".format(
img_id['image_id']))
torch.save(masks, mask_file)
return masks
def __getitem__(self, index):
img_id = self.ids[index]
path = img_id['file_name']
iid = img_id['image_id']
img = Image.open(os.path.join(self.detail.img_folder,
path)).convert('RGB')
if self.mode == 'test':
if self.transform is not None:
img = self.transform(img)
return img, os.path.basename(path)
# convert mask to 60 categories
mask = self.masks[iid]
# 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:
assert self.mode == 'testval'
mask = self._mask_transform(mask)
# general resize, normalize and toTensor
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
mask = self.target_transform(mask)
return img, mask
def _mask_transform(self, mask):
target = np.array(mask).astype('int32') - 1
return torch.from_numpy(target).long()
def __len__(self):
return len(self.ids)
@property
def pred_offset(self):
return 1
def create_detail(u_name, lname, account, email):
"""
Function to create a new detail
"""
new_detail = Detail(u_name, lname, account, email)
return new_detail
#!/usr/bin/env python
import sys
import os.path
curr_dir = os.path.dirname(__file__)
print(curr_dir)
sys.path.append(os.path.abspath(os.path.join(curr_dir, 'crawl')))
#par_dir = os.path.join(curr_dir, os.pardir)
#abs_par_dir = os.path.abspath(par_dir)
#sys.path.append(abs_par_dir)
print(sys.path)
from detail import Detail
proxy_args = {'address': '1.1.1.1', 'port': 2323}
d = Detail(proxy_args)
print(d.address)
print(d.protocol)
def _get_imgs(self, split='trainval'):
""" get images by split type using Detail API. """
annotation = os.path.join(self.root, 'trainval_merged.json')
detail = Detail(annotation, self._img_dir, split)
imgs = detail.getImgs()
return imgs, detail
from detail import Detail
d = Detail()
d.go()
d.addTag('brandan')
d.addTag('apple')
print(d.tags)
def check_existing_details(password):
"""
Function that check if a detail exists with that password and return a Boolean
"""
return Detail.detail_exist(password)
def setUp(self):
'''
Set up method to run before each test cases.
'''
self.new_detail = Detail(
"xyz", "xyz", "2222222222", "*****@*****.**") # create detail object
def delete_details():
"""
Func that rteturns all the saved details
"""
return Detail.delete_details()
def __init__(
self,
root,
list_path,
num_samples=None,
num_classes=59,
multi_scale=True,
flip=True,
ignore_label=-1,
base_size=520,
crop_size=(480, 480),
scale_factor=16,
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
):
super(PASCALContext, self).__init__(ignore_label, base_size, crop_size,
scale_factor, mean, std)
self.root = os.path.abspath(
os.path.join(root, 'pascal_ctx/VOCdevkit/VOC2010'))
self.split = list_path
self.num_classes = num_classes
self.class_weights = None
self.multi_scale = multi_scale
self.flip = flip
self.crop_size = crop_size
# prepare data
annots = os.path.join(self.root, 'trainval_merged.json')
img_path = os.path.join(self.root, 'JPEGImages')
from detail import Detail
if 'val' in self.split:
self.detail = Detail(annots, img_path, 'val')
mask_file = os.path.join(self.root, 'val.pth')
elif 'train' in self.split:
self.mode = 'train'
self.detail = Detail(annots, img_path, 'train')
mask_file = os.path.join(self.root, 'train.pth')
else:
raise ValueError('Only supporting train and val set.')
self.files = self.detail.getImgs()
# generate masks
self._mapping = np.sort(
np.array([
0, 2, 259, 260, 415, 324, 9, 258, 144, 18, 19, 22, 23, 397, 25,
284, 158, 159, 416, 33, 162, 420, 454, 295, 296, 427, 44, 45,
46, 308, 59, 440, 445, 31, 232, 65, 354, 424, 68, 326, 72, 458,
34, 207, 80, 355, 85, 347, 220, 349, 360, 98, 187, 104, 105,
366, 189, 368, 113, 115
]))
self._key = np.array(range(len(self._mapping))).astype('uint8')
print('mask_file:', mask_file)
if os.path.exists(mask_file):
self.masks = torch.load(mask_file)
else:
self.masks = self._preprocess(mask_file)
