Example #1
0
def augmentor(frame_shape):
    """
    Prepares the video data augmentator by applying some augmentations to it
    """
    height = frame_shape[0]
    width = frame_shape[1]
    sometimes = lambda aug: va.Sometimes(
        0.5, aug)  # Used to apply augmentor with 50% probability

    seq = va.Sequential([
        # randomly crop video with a size of (height-60 x width-60)
        # height and width are in this order because the instance is a ndarray
        sometimes(va.RandomCrop(size=(height - 60, width - 60))),
        sometimes(va.HorizontalFlip()),  # horizontally flip
        sometimes(va.Salt(ratio=100)),  # salt
        sometimes(va.Pepper(ratio=100))  # pepper
    ])
    return seq
Example #2
0
 def __init__(self,
              dataset_path,
              jpg_path,
              subset,
              n_samples_for_each_video=10,
              spatial_transform=None,
              temporal_transform=None,
              target_transform=None,
              sample_duration=16,
              get_loader=get_default_video_loader):
     print('n samples:', n_samples_for_each_video)
     self.sample_duration = sample_duration
     self.subset = subset
     self.data, self.scene_labels, self.scene_map, self.class_map = make_dataset(
         dataset_path, jpg_path, subset, n_samples_for_each_video,
         sample_duration)
     self.spatial_transform = spatial_transform
     self.temporal_transform = temporal_transform
     self.target_transform = target_transform
     sometimes = lambda aug: va.Sometimes(
         0.3, aug)  # Used to apply augmentor with 50% probability
     print(subset)
     if self.subset == 'train':
         self.seq = va.Sequential([
             va.RandomRotate(
                 degrees=10
             ),  # randomly rotates the video with a degree randomly choosen from [-10, 10]
             sometimes(va.HorizontalFlip(
             )),  # horizontally flip the video with 50% probability
             sometimes(va.Pepper()),
             sometimes(va.Salt()),
             sometimes(va.RandomTranslate()),
             # sometimes(va.RandomShear()),
             sometimes(va.GaussianBlur(sigma=1)),
             sometimes(va.ElasticTransformation()),
             va.TemporalFit(sample_duration)
         ])
     else:
         self.seq = va.Sequential([va.TemporalFit(sample_duration)])
     self.loader = get_loader()
Example #3
0
import cv2  #
import numpy as np  #  Image
from scipy.ndimage import rotate as rotate_img  #

import random  #  OS
import os  #

WIDTH = HEIGHT = 128
# Augmentations
prob_50 = lambda aug: va.Sometimes(
    0.5, aug)  # Used to apply augmentor with 50% probability
prob_20 = lambda aug: va.Sometimes(
    0.2, aug)  # Used to apply augmentor with 20% probability
aug_seq = va.Sequential([
    prob_20(va.OneOf([va.GaussianBlur(2), va.InvertColor()])),
    prob_50(va.HorizontalFlip())
])


def use_aug_seq(frames):
    aug_frames = []
    for frame in frames:
        if frame is not None:
            aug_frames.append(frame)

    aug_frames = aug_seq(aug_frames)
    j = 0
    for i in range(len(frames)):
        if frames[i] is not None:
            frames[i] = aug_frames[j]
            j += 1
Example #4
0
import imageio
from IPython import display
_VIDEO_LIST = None
from urllib import request  # requires python3
#for augmentation
from vidaug import augmentors as va
from PIL import Image, ImageSequence
import vidaug.augmentors as va
import random

sometimes = lambda aug: va.Sometimes(0.5, aug)
seq = va.Sequential([
    sometimes(va.RandomCrop(size=(224, 224))),
    sometimes(va.RandomRotate(degrees=10)),
    sometimes(va.VerticalFlip()),
    sometimes(va.HorizontalFlip()),
    sometimes(va.GaussianBlur(1.5))
])

no_of_samples = 30
X_train_aug = []
Y_train_aug = []


def augmentation(X_train, Y_train):
    for i in range(no_of_samples):
        idx = random.randint(0, 59)
        print("index is ", idx)
        vid = X_train[idx]
        print("shape of vid", vid.shape)
        #vid = np.expand_dims(vid,3)
from vidaug import augmentors as va
from matplotlib.pyplot import imread
import cv2
import numpy as np

sometimes = lambda aug: va.Sometimes(0.4, aug) # Used to apply augmentor with 50% probability
seq = va.SomeOf([ #va.Sequential([
    # va.RandomCrop(size=(300, 300)), # randomly crop video with a size of (240 x 180)
    # va.RandomRotate(degrees=10), # randomly rotates the video with a degree randomly choosen from [-10, 10]  
    va.RandomTranslate(x=100,y=50), 
    sometimes(va.Add(value=-100)),
    sometimes(va.Pepper(ratio=40)),
    # va.RandomResize(rate=0.5, interp='cubic'),
    sometimes(va.HorizontalFlip()) # horizontally flip the video with 50% probability
], 2)

image = cv2.imread("room.jpg")
image2 = cv2.imread("room3.jpg")
print(image.shape)
# Creating a dataset which contains just one image.
images = np.zeros((2, image.shape[0], image.shape[1], image.shape[2]))
images[0,:,:,:] = image
images[1,:,:,:] = image2

for batch_idx in range(2):
    # 'video' should be either a list of images from type of numpy array or PIL images
    # video = load_batch(batch_idx)
    video_aug = seq(images)
    # train_on_video(video)

    for i in range(2):