def predict(self, predict_data_loader, visualize=True, save_video=False):
# Read params to check if any params have been changed by user
self.params = read_config(self.cfg_path)
#Set model to evaluation mode
self.model.eval()
if save_video:
self.create_video_writer()
with torch.no_grad():
for j, images in enumerate(predict_data_loader):
#Batch operation: depending on batch size more than one image can be processed.
#Set images to self.device
images = images.to(self.device)
#Provide the images as input to the model and save the result in outputs variable.
outputs = self.model(images)
#print images.size()
#for each image in batch
for i in range(outputs.size(0)):
#print(i);
image = images[i] / 255
output = outputs[i]
overlay_img, prob_img = get_output_images(image, output)
plt.figure(figsize=(10, 8))
plt.subplot(1, 3, 1)
plt.imshow(overlay_img)
plt.subplot(1, 3, 2)
plt.imshow(prob_img.detach().cpu().numpy())
plt.subplot(1, 3, 3)
prob_img = prob_img > 0.5
plt.imshow(prob_img.detach().cpu().numpy())
plt.show()
#Get overlay image and probability map using function from utils.visualization
#Convert image, overlay image and probability image to numpy so that it can be visualized using matplotlib functions later. Use convert_tensor_to_numpy function from below.
#if save_video:
#Concatentate input and overlay image(along the width axis [axis=1]) to create video frame. Hint:Use concatenate function from numpy
#Write video frame
#if(visualize):
#display_output(image,prob_img,overlay_img)
if save_video:
self.writer.close()
def predict(self,predict_data_loader,visualize=True,save_video=False):
# Reads params to check if any params have been changed by user
self.params = read_config(self.cfg_path)
#evaluation mode
self.model_p.eval()
if save_video:
self.writer = self.create_video_writer()
with torch.no_grad():
for j, images in enumerate(predict_data_loader):
#Batch operation: depending on batch size more than one image can be processed.
images = images.float()
images = images.to(self.device)
outputs = self.model_p(images)
#for each image in batch
for i in range(outputs.size(0)):
image=images[i]/255
output=outputs[i]
output = torch.unsqueeze(output, 0)
overlay_image, prob_image = get_output_images(image,output)
#Converts image, overlay image and probability image to numpy so that it can be visualized using matplotlib functions later.
image = self.convert_tensor_to_numpy(image)
overlay_image_np = self.convert_tensor_to_numpy(overlay_image)
prob_image_np = self.convert_tensor_to_numpy(prob_image)
if save_video:
#Concatentates input and overlay image(along the width axis [axis=1]) to create video frame.
video_frame = np.concatenate((image, overlay_image_np), axis=1)
video_frame= video_frame * 255
video_frame = video_frame.astype(np.uint8)
#Writes video frame
self.writer.writeFrame(video_frame)
if(visualize):
display_output(image, prob_image_np, overlay_image_np)
if save_video:
self.writer.close()
return play_notebook_video(self.params['output_data_path'], self.params['trained_model_name'])
def __init__(self,
dataset_name,
size,
cfg_path,
mode=Mode.TRAIN,
dataset_parent_path=DEFAULT_DATA_PATH,
augmentation=None,
seed=1):
"""
Args:
dataset_name (string): Folder name of the dataset.
size (int):
No of images to be used from the dataset folder
mode (enumeration Mode):
Nature of operation to be done with the data.
Possibe inputs are Mode.PREDICt,Mode.TRAIN,Mode.TEST
Default value: Mode.TRAIN
dataset_parent_path (string):
Path of the folder where the dataset folder is present
Default: DEFAULT_DATA_PATH as per config.json
cfg_path (string):
Config file path of your experiment
augmentation(Augmentation object):
Augmentation to be applied on the dataset. Augmentation is passed using the object
from Compose class (see augmentation.py)
seed
Seed used for random functions
Default:1
"""
params = read_config(cfg_path)
self.cfg_path = params['cfg_path']
self.detections_file_name = params['detections_file_name']
self.mode = mode
self.dataset_path = os.path.join(dataset_parent_path, dataset_name)
self.datset_name = dataset_name
self.size = size
self.augmentation = augmentation
#Initialize Database inorder to get image list. This is will stored in self.img_list
self.img_list = img_list
def __init__(self,cfg_path):
self.params = read_config(cfg_path)
self.cfg_path = cfg_path
self.setup_cuda()
def predict(self,predict_data_loader,visualize=True,save_video=False):
# Read params to check if any params have been changed by user
self.params = read_config(self.cfg_path)
#Set model to evaluation mode
self.model.eval();
if save_video:
self.create_video_writer()
with torch.no_grad():
for j, images in enumerate(predict_data_loader):
#Batch operation: depending on batch size more than one image can be processed.
#Set images to self.device
images = images.to(self.device);
#Provide the images as input to the model and save the result in outputs variable.
outputs = self.model(images);
#for each image in batch
for i in range(outputs.size(0)):
image=images[i]/255
output=outputs[i]
#Get overlay image and probability map using function from utils.visualization
#Convert image, overlay image and probability image to numpy so that it can be visualized using matplotlib functions later. Use convert_tensor_to_numpy function from below.
if save_video:
#Concatentate input and overlay image(along the width axis [axis=1]) to create video frame. Hint:Use concatenate function from numpy
#Write video frame
if(visualize):
display_output(image,prob_img,overlay_img)
if save_video:
self.writer.close()
#Uncomment the below line and replace ??? with the appropriate filename
#return play_notebook_video(self.params['output_data_path'],???)
def create_video_writer(self):
'''Initialize the video writer'''
filename="outputvideo.webm"
output_path=self.params['output_data_path']
self.writer = skvideo.io.FFmpegWriter(os.path.join(output_path, filename).encode('ascii'),
outputdict={'-vcodec':'libvpx-vp9','-r':'25','-pix_fmt':'yuv420p','-quality':'good','-speed':'2','-threads':'6'},
)
def convert_tensor_to_numpy(self,tensor_img):
'''
Convert the tensor image to a numpy image
'''
#torch has numpy function but it requires the device to be cpu
np_img = img.transpose((1, 2, 0));
# np_img image is now in C X H X W
# transpose the array to H x W x C
return np_img
def __init__(self,cfg_path):
self.params = read_config(cfg_path)
class Img_dataset(Dataset):
"""
Class representing Image Dataset
This class is used to represent both Simulation datasets and true negative real world image datasets.
The images are also returned in the HEIGHT and WIDTH obtained from the simulator config.
Depending on the mode specified by the user, the Dataset returns labels for train and test modes.
User also has the option of choosing smaller sample from a folder containg large number of images by setting the size
parameter
"""
DEFAULT_DATA_PATH = read_config('./config.json')['input_data_path']
def __init__(self,
dataset_name,
size,
cfg_path,
mode=Mode.TRAIN,
dataset_parent_path=DEFAULT_DATA_PATH,
augmentation=None,
seed=1):
"""
Args:
dataset_name (string): Folder name of the dataset.
size (int):
No of images to be used from the dataset folder
mode (enumeration Mode):
Nature of operation to be done with the data.
Possibe inputs are Mode.PREDICt,Mode.TRAIN,Mode.TEST
Default value: Mode.TRAIN
dataset_parent_path (string):
Path of the folder where the dataset folder is present
Default: DEFAULT_DATA_PATH as per config.json
cfg_path (string):
Config file path of your experiment
augmentation(Augmentation object):
Augmentation to be applied on the dataset. Augmentation is passed using the object
from Compose class (see augmentation.py)
seed
Seed used for random functions
Default:1
"""
params = read_config(cfg_path)
self.cfg_path = params['cfg_path']
self.detections_file_name = params['detections_file_name']
self.mode = mode
self.dataset_path = os.path.join(dataset_parent_path, dataset_name)
self.datset_name = dataset_name
self.size = size
self.augmentation = augmentation
self.dataset_parent_path = dataset_parent_path
self.img_list = self._init_dataset(dataset_name, seed, params)
def __len__(self):
'''Returns length of the dataset'''
return self.size
def __getitem__(self, idx):
'''
Using self.img_list and the argument value idx, return images and labels(if applicable based on Mode)
The images and labels are returned in torch tensor format.
'''
#Reads images using files name availble in self.img_list
img = imread(self.img_list[idx])
img = resize(img, (HEIGHT, WIDTH))
#Conversion to ubyte value range (0...255) is done here, because network needs to be trained and needs to predict using the same datatype.
img = img_as_ubyte(img)
if self.mode == Mode.PREDICT:
img = img.transpose((2, 0, 1))
img = torch.from_numpy(img)
return img
#If mode is not PREDICT, Obtains binary label image
else:
label_point_cloud = read_detection(
os.path.join(self.dataset_path, self.detections_file_name),
os.path.basename(self.img_list[idx]))
x = label_point_cloud[0]
y = label_point_cloud[1]
label = np.zeros((img.shape[0], img.shape[1]))
label[x, y] = 1
#Apply augmentation if applicable
#Converts image and label to tensor and returns image,label
img = img.transpose((2, 0, 1))
img = torch.from_numpy(img)
label = torch.from_numpy(label)
return img, label
def _init_dataset(self, dataset_name, seed, params):
'''
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
# Checks if the dataset directory exists
if os.path.isdir(self.dataset_path):
# If dataset directory found: Collects the file names of all images and stores them to a list
image_list = os.listdir(self.dataset_path)
img_list = []
for item in image_list:
if ((re.search(".png", str(item)))
or (re.search(".jpeg", str(item)))
or (re.search(".jpg", str(item)))):
img_list.append(os.path.join(self.dataset_path, item))
if len(img_list) < self.size:
print(
'The size you requested is more than the total available images.'
)
self.size = len(img_list)
self.img_list = img_list
elif len(img_list) > self.size:
print(
'The size you requested is less than the total available images. The desired number of images randomly will be picked.'
)
random.seed(seed)
random.shuffle(img_list)
self.img_list = []
self.img_list = img_list[:self.size]
# would contain number of images as specified by user.
elif len(img_list) == self.size:
self.img_list = img_list
# If dataset directory not found: Runs the simulator and obtain img list from simulation dataset.
else:
self.dataset_path = simulation_pipeline(params, self.size,
dataset_name, seed)
image_list = os.listdir(self.dataset_path)
self.img_list = []
for item in image_list:
if ((re.search(".png", str(item)))
or (re.search(".jpeg", str(item)))
or (re.search(".jpg", str(item)))):
self.img_list.append(os.path.join(self.dataset_path, item))
# Checks if detection file is present in the folder and if it is not present creates a true
# negative detection file using label_true_negatives function from pipelines.py
#will be done from pipeline, through the point cloud.
if not os.path.isfile(
os.path.join(self.dataset_path, self.detections_file_name)):
label_true_negatives(self.dataset_path, self.detections_file_name)
# CODE FOR CONFIG FILE TO RECORD DATASETS USED
# Saves the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)
return self.img_list
def _init_dataset(self, dataset_name, seed, params):
'''
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
# Checks if the dataset directory exists
if os.path.isdir(self.dataset_path):
# If dataset directory found: Collects the file names of all images and stores them to a list
image_list = os.listdir(self.dataset_path)
img_list = []
for item in image_list:
if ((re.search(".png", str(item)))
or (re.search(".jpeg", str(item)))
or (re.search(".jpg", str(item)))):
img_list.append(os.path.join(self.dataset_path, item))
if len(img_list) < self.size:
print(
'The size you requested is more than the total available images.'
)
self.size = len(img_list)
self.img_list = img_list
elif len(img_list) > self.size:
print(
'The size you requested is less than the total available images. The desired number of images randomly will be picked.'
)
random.seed(seed)
random.shuffle(img_list)
self.img_list = []
self.img_list = img_list[:self.size]
# would contain number of images as specified by user.
elif len(img_list) == self.size:
self.img_list = img_list
# If dataset directory not found: Runs the simulator and obtain img list from simulation dataset.
else:
self.dataset_path = simulation_pipeline(params, self.size,
dataset_name, seed)
image_list = os.listdir(self.dataset_path)
self.img_list = []
for item in image_list:
if ((re.search(".png", str(item)))
or (re.search(".jpeg", str(item)))
or (re.search(".jpg", str(item)))):
self.img_list.append(os.path.join(self.dataset_path, item))
# Checks if detection file is present in the folder and if it is not present creates a true
# negative detection file using label_true_negatives function from pipelines.py
#will be done from pipeline, through the point cloud.
if not os.path.isfile(
os.path.join(self.dataset_path, self.detections_file_name)):
label_true_negatives(self.dataset_path, self.detections_file_name)
# CODE FOR CONFIG FILE TO RECORD DATASETS USED
# Saves the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)
return self.img_list
from torch.utils.data import Dataset
import torch
from specs import *
from serde import read_detection, read_config, write_config
from pipelines import simulation_pipeline
from Training import Mode
from pipelines import label_true_negatives
from config import sim_config
import random
import re
sc = sim_config()['simulator']
HEIGHT = sc['height']
WIDTH = sc['width']
DEFAULT_DATA_PATH = read_config('./config.json')['input_data_path']
class Img_dataset(Dataset):
"""
Class representing Image Dataset
This class is used to represent both Simulation datasets and true negative real world image datasets.
The images are also returned in the HEIGHT and WIDTH obtained from the simulator config.
Depending on the mode specified by the user, the Dataset returns labels for train and test modes.
User also has the option of choosing smaller sample from a folder containg large number of images by setting the size
parameter
"""
DEFAULT_DATA_PATH = read_config('./config.json')['input_data_path']
def __init__(self,
dataset_name,
def __init__(self, cfg_path):
self.params = read_config(cfg_path)
self.cfg_path = cfg_path
self.model_info = self.params['Network']
self.model_info['seed'] = self.model_info['seed']
self.setup_cuda()
class Img_dataset(Dataset):
"""
Class representing Image Dataset
This class is used to represent both Simulation datasets and true negative real world image datasets.
The images are also returned in the HEIGHT and WIDTH obtained from the simulator config.
Depending on the mode specified by the user, the Dataset return labels for train and test modes.
User also has the option of choosing smaller sample from a folder containg large number of images by setting the size
parameter
Refer: https://pytorch.org/tutorials/beginner/data_loading_tutorial.html
"""
DEFAULT_DATA_PATH = read_config('./config.json')['input_data_path']
def __init__(self,
dataset_name,
size,
cfg_path,
mode=Mode.TRAIN,
dataset_parent_path=DEFAULT_DATA_PATH,
augmentation=None,
seed=1):
"""
Args:
dataset_name (string): Folder name of the dataset.
size (int):
No of images to be used from the dataset folder
mode (enumeration Mode):
Nature of operation to be done with the data.
Possibe inputs are Mode.PREDICt,Mode.TRAIN,Mode.TEST
Default value: Mode.TRAIN
dataset_parent_path (string):
Path of the folder where the dataset folder is present
Default: DEFAULT_DATA_PATH as per config.json
cfg_path (string):
Config file path of your experiment
augmentation(Augmentation object):
Augmentation to be applied on the dataset. Augmentation is passed using the object
from Compose class (see augmentation.py)
seed
Seed used for random functions
Default:1
"""
params = read_config(cfg_path)
self.cfg_path = params['cfg_path']
self.detections_file_name = params['detections_file_name']
self.mode = mode
self.dataset_path = os.path.join(dataset_parent_path, dataset_name)
self.datset_name = dataset_name
self.size = size
self.augmentation = augmentation
#Initialize Database inorder to get image list. This is will stored in self.img_list
self.img_list = img_list
def __len__(self):
'''Returns length of the dataset'''
return self.size
def __getitem__(self, idx):
'''
Using self.img_list and the argument value idx, return images and labels(if applicable based on Mode)
The images and labels are returned in torch tensor format
'''
#Read images using files name availble in self.img_list
#Resize image if required
#If mode is PREDICT, convert image to tensor and return the image
if self.mode == Mode.PREDICT:
# Convert image to tensor and return image
return img
#If mode is not PREDICT, and retun image ,label
#Obtain label from the detection file
#Apply augmentation if applicable
#Convert image and label to tensor and returm image,label
return img, label
def _init_dataset(self, dataset_name, seed, params):
'''
Initialize Dataset: Get the list the list of images from the dataset folder.
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
# Check if the dataset directory exists
# If dataset directory found: Collect the file names of all images and store them to a list
#Compare number of images in img_list with size provided by user and then assign img_list to self.img_list
#If number of images < size: inform user about the availabe image count
#and change value of self.size to number of images in img_list
#assign img_list to self.img_list without changes
# if number of images >size : inform user about the availabe image count
# Randomly select images from img_list and assign them into self.img_list such that self.img_list
# would contain number of images as specified by user. (Use the seed specified by user for random function)
# If number of images = size
# assign img_list to self.img_list without changes
# If dataset directory not found: Run the simulator and obtain img list from simulation dataset
# Check if detection file is present in the folder and if it is not present create a true
# negative detection file using label_true_negatives function from pipelines.py
#DO NOT CHANGE: CODE FOR CONFIG FILE TO RECORD DATASETS USED
#Save the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)
def _init_dataset(self, dataset_name, seed, params):
'''
Initialize Dataset: Get the list the list of images from the dataset folder.
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
# Check if the dataset directory exists
# If dataset directory found: Collect the file names of all images and store them to a list
#Compare number of images in img_list with size provided by user and then assign img_list to self.img_list
#If number of images < size: inform user about the availabe image count
#and change value of self.size to number of images in img_list
#assign img_list to self.img_list without changes
# if number of images >size : inform user about the availabe image count
# Randomly select images from img_list and assign them into self.img_list such that self.img_list
# would contain number of images as specified by user. (Use the seed specified by user for random function)
# If number of images = size
# assign img_list to self.img_list without changes
# If dataset directory not found: Run the simulator and obtain img list from simulation dataset
# Check if detection file is present in the folder and if it is not present create a true
# negative detection file using label_true_negatives function from pipelines.py
#DO NOT CHANGE: CODE FOR CONFIG FILE TO RECORD DATASETS USED
#Save the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)
def _init_dataset(self, dataset_name, seed, params):
'''
Initialize Dataset: Get the list the list of images from the dataset.
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
# Check if the directory exists
if os.path.isdir(self.dataset_path):
# Collect the file names of all images and store them to a list
img_list = [
name for name in os.listdir(self.dataset_path)
if name.endswith(('.jpg', '.jpeg', '.png'))
]
image_count_in_folder = len(img_list)
#Compare number of images in img_list with size provided by user and then assign img_list to self.img_list
#If number of images < size: inform user about the available image count
#and change value of self.size to number of images in img_list
#assign img_list to self.img_list without changes
if image_count_in_folder < self.size:
print(
'{0}\nImages availabe in folder: \t{1}\nGiven Size: \t\t\t{2}\n'
'Images used in dataset: \t{1}\n\n\n'.format(
dataset_name, image_count_in_folder, self.size))
self.size = len(img_list)
self.img_list = img_list
# if number of images >size : inform user about the availabe image count
#Randomly select images from img_list and assign them into self.img_list such that self.img_list
# would contain number of images as specified by user. (Use the seed specified by user for random function)
elif image_count_in_folder > self.size:
np.random.seed(seed)
idx = np.random.choice(image_count_in_folder, self.size)
self.img_list = [img_list[i] for i in idx]
print(
'{0}\nImages availabe in folder: \t{1}\nGiven Size: \t\t\t{2} \n'
'Images used in dataset: \t{2}\n\n\n'.format(
dataset_name, image_count_in_folder, self.size))
# If number of images = size
# assign img_list to self.img_list without changes
else:
self.img_list = img_list
else:
# Run the simulator and save the results in the dataset path
simulation_pipeline(params, self.size, dataset_name, seed)
self.img_list = [
name for name in os.listdir(self.dataset_path)
if name.endswith(('.jpg', '.jpeg', '.png'))
]
#Check if detection file is present in the folder and if it is not present create a true negative(dummy) detection file using
#label_true_negatives function from pipelines.py
if not os.path.exists(
os.path.join(self.dataset_path, self.detections_file_name)):
label_true_negatives(self.dataset_path, self.detections_file_name)
#Save the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)
def _init_dataset(self, dataset_name, seed, params):
'''
Initialize Dataset: Get the list the list of images from the dataset folder.
If the dataset is found , the size is checked against the number of images in the folder and
if size is more than number of images in the folder, randomly pick images from the folder so
that number of images is equal to the user specified size.
If the dataset is not found, the simulator is run and a folder containing simulation
images and detection files, is created with the given dataset name.
Final image list is stored into self.img_list
'''
dir_path = os.path.join(DEFAULT_DATA_PATH, dataset_name)
random.seed(seed)
# Check if the dataset directory exists
if (os.path.isdir(dir_path)):
# If dataset directory found: Collect the file names of all images and store them to a list
im_list = [
name for name in os.listdir(dir_path)
if name.endswith(('.jpg', '.jpeg', '.png'))
]
im_num = len(im_list)
if (im_num < self.size):
print("Lesser number of images found! Available: ", im_num)
self.size = im_num
self.img_list = im_list
#Compare number of images in img_list with size provided by user and then assign img_list to self.img_list
#If number of images < size: inform user about the availabe image count
#and change value of self.size to number of images in img_list
#assign img_list to self.img_list without changes
if (im_num > self.size):
# if number of images >size : inform user about the availabe image count
# Randomly select images from img_list and assign them into self.img_list such that self.img_list
# would contain number of images as specified by user. (Use the seed specified by user for random function)
print("More number of images available! Available: ", im_num)
self.img_list = random.sample(im_list, self.size)
if (im_num == self.size):
self.img_list = im_list
else:
# If dataset directory not found: Run the simulator and obtain img list from simulation dataset
simulation_pipeline(params, self.size, dataset_name, seed)
im_list = os.listdir(dir_path)
im_list = np.ravel(im_list)
self.img_list = im_list
dir_path1 = os.path.join(dir_path, self.detections_file_name)
exs = os.path.isfile(dir_path1)
if not exs:
label_true_negatives(dir_path, self.detections_file_name)
# Check if detection file is present in the folder and if it is not present create a true
# negative detection file using label_true_negatives function from pipelines.py
#DO NOT CHANGE: CODE FOR CONFIG FILE TO RECORD DATASETS USED
#Save the dataset information for writing to config file
if self.mode == Mode.TRAIN:
params = read_config(self.cfg_path)
params['Network']['total_dataset_number'] += 1
dataset_key = 'Traing_Dataset_' + str(
params['Network']['total_dataset_number'])
#If augmentation is applied
if self.augmentation:
augmenetation_applied = [
i.__class__.__name__
for i in self.augmentation.augmentation_list
]
else:
augmenetation_applied = None
dataset_info = {
'name': dataset_name,
'path': self.dataset_path,
'size': self.size,
'augmenetation_applied': augmenetation_applied,
'seed': seed
}
params[dataset_key] = dataset_info
write_config(params, params['cfg_path'], sort_keys=True)