utils.py

"""
Copyright (C) 2018 NVIDIA Corporation.  All rights reserved.
Licensed under the CC BY-NC-SA 4.0 license (https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
"""
# from torch.utils.serialization import load_lua
from numpy.linalg.linalg import norm
from torch.utils.data import DataLoader
# from networks import Vgg16
from torch.autograd import Variable
from torch.optim import lr_scheduler
from torchvision import transforms
from torch.distributions.beta import Beta
from data import ImageFilelist, ImageFolder
import torch
import torch.nn as nn
import os
import math
import torchvision.utils as vutil
import yaml
import numpy as np
import torch.nn.init as init
import time
import cv2
import pandas as pd
import matplotlib.pyplot as plt
# import seaborn as sns
# from scipy import stats
# from scipy.stats import beta

# Methods
# get_all_data_loaders      : primary data loader interface (load trainA, testA, trainB, testB)
# get_data_loader_list      : list-based data loader
# get_data_loader_folder    : folder-based data loader
# get_config                : load yaml file
# eformat                   :
# write_2images             : save output image
# prepare_sub_folder        : create checkpoints and images folders for saving outputs
# write_one_row_html        : write one row of the html file for output images
# write_html                : create the html file.
# write_loss
# slerp
# get_slerp_interp
# get_model_list
# load_vgg16
# load_inception
# vgg_preprocess
# get_scheduler
# weights_init
# domain_code_produce_encoder
# domain_code_produce_decoder
# visualize_results_to_video
# get_domainess
# get_domainess_pdf


def get_all_data_loaders(conf):
    batch_size = conf['batch_size']
    num_workers = conf['num_workers']
    if 'new_size' in conf:
        new_size_a = new_size_b = conf['new_size']
    else:
        new_size_a = conf['new_size_a']
        new_size_b = conf['new_size_b']
    height = conf['crop_image_height']
    width = conf['crop_image_width']

    if 'data_root' in conf:
        train_loader_a = get_data_loader_folder(os.path.join(conf['data_root'], 'trainA'), batch_size, True,
                                                new_size_a, height, width, num_workers, True)
        test_loader_a = get_data_loader_folder(os.path.join(conf['data_root'], 'testA'), batch_size, False,
                                               new_size_a, new_size_a, new_size_a, num_workers, True)
        train_loader_b = get_data_loader_folder(os.path.join(conf['data_root'], 'trainB'), batch_size, True,
                                                new_size_b, height, width, num_workers, True)
        test_loader_b = get_data_loader_folder(os.path.join(conf['data_root'], 'testB'), batch_size, False,
                                               new_size_b, new_size_b, new_size_b, num_workers, True)
    else:
        train_loader_a = get_data_loader_list(conf['data_folder_train_a'], conf['data_list_train_a'], batch_size, True,
                                              new_size_a, height, width, num_workers, True)
        test_loader_a = get_data_loader_list(conf['data_folder_test_a'], conf['data_list_test_a'], batch_size, False,
                                             new_size_a, new_size_a, new_size_a, num_workers, True)
        train_loader_b = get_data_loader_list(conf['data_folder_train_b'], conf['data_list_train_b'], batch_size, True,
                                              new_size_b, height, width, num_workers, True)
        test_loader_b = get_data_loader_list(conf['data_folder_test_b'], conf['data_list_test_b'], batch_size, False,
                                             new_size_b, new_size_b, new_size_b, num_workers, True)
    return train_loader_a, train_loader_b, test_loader_a, test_loader_b


def get_data_loader_list(root, file_list, batch_size, train, new_size=None,
                         height=256, width=256, num_workers=4, crop=True):
    transform_list = [transforms.ToTensor(),
                      transforms.Normalize((0.5, 0.5, 0.5),
                                           (0.5, 0.5, 0.5))]
    transform_list = [transforms.RandomCrop(
        (height, width))] + transform_list if crop else transform_list
    transform_list = [transforms.Resize(
        new_size)] + transform_list if new_size is not None else transform_list
    transform_list = [transforms.RandomHorizontalFlip()] + \
        transform_list if train else transform_list
    transform = transforms.Compose(transform_list)
    dataset = ImageFilelist(root, file_list, transform=transform)
    loader = DataLoader(dataset=dataset, batch_size=batch_size,
                        shuffle=train, drop_last=True, num_workers=num_workers)
    return loader


def get_data_loader_folder(input_folder, batch_size, train, new_size=None,
                           height=256, width=256, num_workers=4, crop=True):
    transform_list = [transforms.ToTensor(),
                      transforms.Normalize((0.5, 0.5, 0.5),
                                           (0.5, 0.5, 0.5))]
    transform_list = [transforms.RandomCrop(
        (height, width))] + transform_list if crop else transform_list
    transform_list = [transforms.Resize(
        new_size)] + transform_list if new_size is not None else transform_list
    transform_list = [transforms.RandomHorizontalFlip()] + \
        transform_list if train else transform_list
    transform = transforms.Compose(transform_list)
    dataset = ImageFolder(input_folder, transform=transform)
    loader = DataLoader(dataset=dataset, batch_size=batch_size,
                        shuffle=train, drop_last=True, num_workers=num_workers)
    return loader


def get_config(config):
    with open(config, 'r') as stream:
        return yaml.load(stream)


def eformat(f, prec):
    s = "%.*e" % (prec, f)
    mantissa, exp = s.split('e')
    # add 1 to digits as 1 is taken by sign +/-
    return "%se%d" % (mantissa, int(exp))


def __write_images(image_outputs, display_image_num, file_name):
    # expand gray-scale images to 3 channels
    image_outputs = [images.expand(-1, 3, -1, -1) for images in image_outputs]
    image_tensor = torch.cat([images[:display_image_num]
                              for images in image_outputs], 0)
    image_grid = vutils.make_grid(
        image_tensor.data, nrow=display_image_num, padding=0, normalize=True)
    vutils.save_image(image_grid, file_name, nrow=1)


def write_2images(image_outputs, display_image_num, image_directory, postfix):
    n = len(image_outputs)
    __write_images(image_outputs[0:n//2], display_image_num,
                   '%s/gen_a2b_%s.jpg' % (image_directory, postfix))
    __write_images(image_outputs[n//2:n], display_image_num,
                   '%s/gen_b2a_%s.jpg' % (image_directory, postfix))


def prepare_sub_folder(output_directory):
    image_directory = os.path.join(output_directory, 'images')
    if not os.path.exists(image_directory):
        print("Creating directory: {}".format(image_directory))
        os.makedirs(image_directory)
    checkpoint_directory = os.path.join(output_directory, 'checkpoints')
    if not os.path.exists(checkpoint_directory):
        print("Creating directory: {}".format(checkpoint_directory))
        os.makedirs(checkpoint_directory)
    test_directory = os.path.join(output_directory, 'test')
    if not os.path.exists(test_directory):
        print("Creating directory: {}".format(test_directory))
        os.makedirs(test_directory)

    generated_directory = os.path.join(output_directory, 'generated')
    if not os.path.exists(generated_directory):
        print("Creating directory: {}".format(generated_directory))
        os.makedirs(generated_directory)

    interpolation_directory = os.path.join(output_directory, 'interpolation')
    if not os.path.exists(interpolation_directory):
        print("Creating directory: {}".format(interpolation_directory))
        os.makedirs(interpolation_directory)

    return checkpoint_directory, image_directory


def write_one_row_html(html_file, iterations, img_filename, all_size):
    html_file.write("<h3>iteration [%d] (%s)</h3>" %
                    (iterations, img_filename.split('/')[-1]))
    html_file.write("""
        <p><a href="%s">
          <img src="%s" style="width:%dpx">
        </a><br>
        <p>
        """ % (img_filename, img_filename, all_size))
    return


def write_html(filename, iterations, image_save_iterations, image_directory, all_size=1536):
    html_file = open(filename, "w")
    html_file.write('''
    <!DOCTYPE html>
    <html>
    <head>
      <title>Experiment name = %s</title>
      <meta http-equiv="refresh" content="30">
    </head>
    <body>
    ''' % os.path.basename(filename))
    html_file.write("<h3>current</h3>")
    write_one_row_html(html_file, iterations,
                       '%s/gen_a2b_train_current.jpg' % (image_directory), all_size)
    write_one_row_html(html_file, iterations,
                       '%s/gen_b2a_train_current.jpg' % (image_directory), all_size)
    for j in range(iterations, image_save_iterations-1, -1):
        if j % image_save_iterations == 0:
            write_one_row_html(
                html_file, j, '%s/gen_a2b_test_%08d.jpg' % (image_directory, j), all_size)
            write_one_row_html(
                html_file, j, '%s/gen_b2a_test_%08d.jpg' % (image_directory, j), all_size)
            write_one_row_html(
                html_file, j, '%s/gen_a2b_train_%08d.jpg' % (image_directory, j), all_size)
            write_one_row_html(
                html_file, j, '%s/gen_b2a_train_%08d.jpg' % (image_directory, j), all_size)
    html_file.write("</body></html>")
    html_file.close()


def write_loss(iterations, trainer, train_writer):
    members = [attr for attr in dir(trainer)
               if not callable(getattr(trainer, attr)) and not attr.startswith("__") and ('loss' in attr or 'grad' in attr or 'nwd' in attr)]
    for m in members:
        train_writer.add_scalar(m, getattr(trainer, m), iterations + 1)


class lerp(nn.Module):
    def __init__(self):
        super(lerp, self).__init__()

    def forward(self, val, low, high):
        return torch.mul((1-val), low) + torch.mul(val, high)


class slerp(nn.Module):
    def __init__(self):
        super(slerp, self).__init__()

    def forward(self, val, low, high):
        omega = torch.acos(torch.dot(
            low.view(-1) / torch.norm(low.view(-1)), high.view(-1) / torch.norm(high.view(-1))))
        so = torch.sin(omega)
        return torch.sin((1.0 - val) * omega) / so * low + torch.sin(val * omega) / so * high

# def lerp(val, low, high):
#     return (1-val)*low + val*high

# val = z_style (ratio)
# def slerp(val, low, high):
#     """
#     original: Animating Rotation with Quaternion Curves, Ken Shoemake
#     https://arxiv.org/abs/1609.04468
#     Code: https://github.com/soumith/dcgan.torch/issues/14, Tom White
#     """
#     # omega = np.arccos(np.dot(low / np.linalg.norm(low), high / np.linalg.norm(high)))
#     # so = np.sin(omega)
#     # return np.sin((1.0 - val) * omega) / so * low + np.sin(val * omega) / so * high

#     omega = torch.acos(torch.dot(low.view(-1)/ torch.norm(low.view(-1)), high.view(-1) / torch.norm(high.view(-1))))
#     so = torch.sin(omega)
#     return torch.sin((1.0 - val) * omega) / so * low + torch.sin(val * omega) / so * high


def get_slerp_interp(nb_latents, nb_interp, z_dim):
    """
    modified from: PyTorch inference for "Progressive Growing of GANs" with CelebA snapshot
    https://github.com/ptrblck/prog_gans_pytorch_inference
    """

    latent_interps = np.empty(shape=(0, z_dim), dtype=np.float32)
    for _ in range(nb_latents):
        low = np.random.randn(z_dim)
        high = np.random.randn(z_dim)  # low + np.random.randn(512) * 0.7
        interp_vals = np.linspace(0, 1, num=nb_interp)
        latent_interp = np.array([slerp(v, low, high) for v in interp_vals],
                                 dtype=np.float32)
        latent_interps = np.vstack((latent_interps, latent_interp))

    return latent_interps[:, :, np.newaxis, np.newaxis]


# Get model list for resume
def get_model_list(dirname, key):
    if os.path.exists(dirname) is False:
        return None
    gen_models = [os.path.join(dirname, f) for f in os.listdir(dirname) if
                  os.path.isfile(os.path.join(dirname, f)) and key in f and ".pt" in f]
    if gen_models is None:
        return None
    gen_models.sort()
    last_model_name = gen_models[-1]
    return last_model_name


def load_vgg16(model_dir):
    """ Use the model from https://github.com/abhiskk/fast-neural-style/blob/master/neural_style/utils.py """
    if not os.path.exists(model_dir):
        os.mkdir(model_dir)
    if not os.path.exists(os.path.join(model_dir, 'vgg16.weight')):
        if not os.path.exists(os.path.join(model_dir, 'vgg16.t7')):
            os.system('wget https://www.dropbox.com/s/76l3rt4kyi3s8x7/vgg16.t7?dl=1 -O ' +
                      os.path.join(model_dir, 'vgg16.t7'))
        vgglua = load_lua(os.path.join(model_dir, 'vgg16.t7'))
        vgg = Vgg16()
        for (src, dst) in zip(vgglua.parameters()[0], vgg.parameters()):
            dst.data[:] = src
        torch.save(vgg.state_dict(), os.path.join(model_dir, 'vgg16.weight'))
    vgg = Vgg16()
    vgg.load_state_dict(torch.load(os.path.join(model_dir, 'vgg16.weight')))
    return vgg


def load_inception(model_path):
    state_dict = torch.load(model_path)
    model = inception_v3(pretrained=False, transform_input=True)
    model.aux_logits = False
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, state_dict['fc.weight'].size(0))
    model.load_state_dict(state_dict)
    for param in model.parameters():
        param.requires_grad = False
    return model


def vgg_preprocess(batch):
    tensortype = type(batch.data)
    (r, g, b) = torch.chunk(batch, 3, dim=1)
    batch = torch.cat((b, g, r), dim=1)  # convert RGB to BGR
    batch = (batch + 1) * 255 * 0.5  # [-1, 1] -> [0, 255]
    mean = tensortype(batch.data.size()).cuda()
    mean[:, 0, :, :] = 103.939
    mean[:, 1, :, :] = 116.779
    mean[:, 2, :, :] = 123.680
    batch = batch.sub(Variable(mean))  # subtract mean
    return batch


def get_scheduler(optimizer, hyperparameters, iterations=-1):
    if 'lr_policy' not in hyperparameters or hyperparameters['lr_policy'] == 'constant':
        scheduler = None  # constant scheduler
    elif hyperparameters['lr_policy'] == 'step':
        scheduler = lr_scheduler.StepLR(optimizer, step_size=hyperparameters['step_size'],
                                        gamma=hyperparameters['gamma'], last_epoch=iterations)
    else:
        return NotImplementedError('learning rate policy [%s] is not implemented', hyperparameters['lr_policy'])
    return scheduler


def weights_init(init_type='gaussian'):
    def init_fun(m):
        classname = m.__class__.__name__
        if (classname.find('Conv') == 0 or classname.find('Linear') == 0) and hasattr(m, 'weight'):
            # print m.__class__.__name__
            if init_type == 'gaussian':
                init.normal_(m.weight.data, 0.0, 0.02)
            elif init_type == 'xavier':
                init.xavier_normal_(m.weight.data, gain=math.sqrt(2))
            elif init_type == 'kaiming':
                init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
            elif init_type == 'orthogonal':
                init.orthogonal_(m.weight.data, gain=math.sqrt(2))
            elif init_type == 'default':
                pass
            else:
                assert 0, "Unsupported initialization: {}".format(init_type)
            if hasattr(m, 'bias') and m.bias is not None:
                init.constant_(m.bias.data, 0.0)

    return init_fun


class Timer:
    def __init__(self, msg):
        self.msg = msg
        self.start_time = None

    def __enter__(self):
        self.start_time = time.time()

    def __exit__(self, exc_type, exc_value, exc_tb):
        print(self.msg % (time.time() - self.start_time))


def pytorch03_to_pytorch04(state_dict_base, trainer_name):
    def __conversion_core(state_dict_base, trainer_name):
        state_dict = state_dict_base.copy()
        if trainer_name == 'MUNIT':
            for key, value in state_dict_base.items():
                if key.endswith(('enc_content.model.0.norm.running_mean',
                                 'enc_content.model.0.norm.running_var',
                                 'enc_content.model.1.norm.running_mean',
                                 'enc_content.model.1.norm.running_var',
                                 'enc_content.model.2.norm.running_mean',
                                 'enc_content.model.2.norm.running_var',
                                 'enc_content.model.3.model.0.model.1.norm.running_mean',
                                 'enc_content.model.3.model.0.model.1.norm.running_var',
                                 'enc_content.model.3.model.0.model.0.norm.running_mean',
                                 'enc_content.model.3.model.0.model.0.norm.running_var',
                                 'enc_content.model.3.model.1.model.1.norm.running_mean',
                                 'enc_content.model.3.model.1.model.1.norm.running_var',
                                 'enc_content.model.3.model.1.model.0.norm.running_mean',
                                 'enc_content.model.3.model.1.model.0.norm.running_var',
                                 'enc_content.model.3.model.2.model.1.norm.running_mean',
                                 'enc_content.model.3.model.2.model.1.norm.running_var',
                                 'enc_content.model.3.model.2.model.0.norm.running_mean',
                                 'enc_content.model.3.model.2.model.0.norm.running_var',
                                 'enc_content.model.3.model.3.model.1.norm.running_mean',
                                 'enc_content.model.3.model.3.model.1.norm.running_var',
                                 'enc_content.model.3.model.3.model.0.norm.running_mean',
                                 'enc_content.model.3.model.3.model.0.norm.running_var',
                                 )):
                    del state_dict[key]
        else:
            def __conversion_core(state_dict_base):
                state_dict = state_dict_base.copy()
                for key, value in state_dict_base.items():
                    if key.endswith(('enc.model.0.norm.running_mean',
                                     'enc.model.0.norm.running_var',
                                     'enc.model.1.norm.running_mean',
                                     'enc.model.1.norm.running_var',
                                     'enc.model.2.norm.running_mean',
                                     'enc.model.2.norm.running_var',
                                     'enc.model.3.model.0.model.1.norm.running_mean',
                                     'enc.model.3.model.0.model.1.norm.running_var',
                                     'enc.model.3.model.0.model.0.norm.running_mean',
                                     'enc.model.3.model.0.model.0.norm.running_var',
                                     'enc.model.3.model.1.model.1.norm.running_mean',
                                     'enc.model.3.model.1.model.1.norm.running_var',
                                     'enc.model.3.model.1.model.0.norm.running_mean',
                                     'enc.model.3.model.1.model.0.norm.running_var',
                                     'enc.model.3.model.2.model.1.norm.running_mean',
                                     'enc.model.3.model.2.model.1.norm.running_var',
                                     'enc.model.3.model.2.model.0.norm.running_mean',
                                     'enc.model.3.model.2.model.0.norm.running_var',
                                     'enc.model.3.model.3.model.1.norm.running_mean',
                                     'enc.model.3.model.3.model.1.norm.running_var',
                                     'enc.model.3.model.3.model.0.norm.running_mean',
                                     'enc.model.3.model.3.model.0.norm.running_var',

                                     'dec.model.0.model.0.model.1.norm.running_mean',
                                     'dec.model.0.model.0.model.1.norm.running_var',
                                     'dec.model.0.model.0.model.0.norm.running_mean',
                                     'dec.model.0.model.0.model.0.norm.running_var',
                                     'dec.model.0.model.1.model.1.norm.running_mean',
                                     'dec.model.0.model.1.model.1.norm.running_var',
                                     'dec.model.0.model.1.model.0.norm.running_mean',
                                     'dec.model.0.model.1.model.0.norm.running_var',
                                     'dec.model.0.model.2.model.1.norm.running_mean',
                                     'dec.model.0.model.2.model.1.norm.running_var',
                                     'dec.model.0.model.2.model.0.norm.running_mean',
                                     'dec.model.0.model.2.model.0.norm.running_var',
                                     'dec.model.0.model.3.model.1.norm.running_mean',
                                     'dec.model.0.model.3.model.1.norm.running_var',
                                     'dec.model.0.model.3.model.0.norm.running_mean',
                                     'dec.model.0.model.3.model.0.norm.running_var',
                                     )):
                        del state_dict[key]
        return state_dict

    state_dict = dict()
    state_dict['a'] = __conversion_core(state_dict_base['a'], trainer_name)
    state_dict['b'] = __conversion_core(state_dict_base['b'], trainer_name)
    return state_dict

# for example  domain=2
# dimension (batch_size, dom_num, img_size, img_size)
# output data will be  [all_1, 0 is 1 , 1 is 1]


def domain_code_produce_encoder(batch_size, img_size, dom_num):
    # domain num : the number of domain
    # 0 : for mixer domain
    dom_codes = [torch.ones(batch_size, dom_num, img_size, img_size).cuda()]
    for i in range(dom_num):
        dom_code = torch.zeros(batch_size, dom_num, img_size, img_size)
        dom_code[:, i, :, :] = torch.ones(1, img_size, img_size)
        dom_codes.append(dom_code.cuda())
    return dom_codes


def domain_code_produce_decoder(batch_size, dom_num):
    dom_codes = [torch.ones(batch_size, dom_num, 1, 1).cuda()]
    for i in range(dom_num):
        dom_code = torch.zeros(batch_size, dom_num, 1, 1)
        dom_code[:, i, :, :] = torch.ones(1)
        dom_codes.append(dom_code.cuda())
    return dom_codes


def visualize_results_to_video(input_directory, output_directory, fps=5):
    case = ['a2b_train', 'a2b_test', 'b2a_train', 'b2a_test']
    for vdo_name in case:
        images_list = glob.glob(f'{input_directory}/*{vdo_name}*')
        # vdo_name = images_list[0][-22:-13]
        frame_array = []
        # for sorting the file names properly
        images_list.sort(key=lambda x: x[-12:-4])
        for img_pth in images_list:
            img = cv2.imread(img_pth)
            height, width, channels = img.shape
            size = (width, height)
            # inserting the frames into an image array
            frame_array.append(img)
        out = cv2.VideoWriter(
            f'{output_directory}/{vdo_name}.avi', cv2.VideoWriter_fourcc(*'DIVX'), fps, size)
        for i in range(len(frame_array)):
            # writing to a image array
            out.write(frame_array[i])
        out.release()


def get_domainess(cur_iter, total_iter, batch, distribution_type='uniform'):
    """distribution_type : uniform / beta"""
    if distribution_type == 'beta':
        alpha = np.exp((cur_iter - (0.5 * total_iter)) / (0.25 * total_iter))
        distribution = Beta(alpha, 1)
        rand_num = torch.randint(0, 2, (1,))  # range 0-1
        if rand_num == 0:
            return distribution.sample((batch, 1)).cuda()
        elif rand_num == 1:
            return 1-distribution.sample((batch, 1)).cuda()

    elif distribution_type == 'uniform':
        distribution = torch.distributions.uniform.Uniform(0, 1)
        return distribution.sample((batch, 1)).cuda()


def get_domainess_pdf(cur_iter, total_iter, sample_num=10000):
    alpha = np.exp((cur_iter - (0.5 * total_iter)) / (0.25 * total_iter))
    x = np.linspace(beta.ppf(0.0001, alpha, 1),
                    beta.ppf(0.9999, alpha, 1), sample_num)
    density = beta.pdf(x, alpha, 1)
    return alpha, x, density


if __name__ == '__main__':
    import glob
    in_pth = "/home/cymb103u/Desktop/Workspace/master/MASTER_MUNIT/outputs/style_shoes_label_folder_v6/images"
    out_pth = "/home/cymb103u/Desktop/Workspace/master/MASTER_MUNIT/outputs/style_shoes_label_folder_v6/"
    visualize_results_to_video(in_pth, out_pth)
    # print(type(img_list))

    # x = np.array([1.223,-1.2,0.745,2.7,-3.501])
    # y = np.array([2.01,.1415,-4.76,-0.50004,1.56])
    # value = slerp(0.3,x,y)
    # print(value)
    # x = torch.FloatTensor([1.223,-1.2,0.745,2.7,-3.501])
    # y = torch.FloatTensor([2.01,.1415,-4.76,-0.50004,1.56])
    # value = slerp(0.3,x,y)
    # print(value)
    # # visualize distribution
    # total_iter = 100000
    # sample_iter = np.linspace(0,total_iter,500,dtype=np.int)
    # for current_iter in sample_iter:
    #     alpha, x, density = get_domainess_pdf(current_iter,total_iter)
    #     # figure set
    #     plt.grid()
    #     plt.title(f'Be({alpha:.4f},1),current={current_iter:07d}')
    #     plt.xlabel('x')
    #     plt.ylabel('Density')
    #     ## control x axe and y axe range
    #     plt.xlim(0, 1)
    #     plt.ylim(0,8)
    #     plt.plot(x, density,'r-', linewidth=1, alpha=0.6, label='beta pdf')
    #     plt.savefig(f'beta_distribution_figures/plt_{current_iter:07d}iter.jpg')
    #     plt.clf()

    # # distribution to vdo
    # images_list = glob.glob(f'beta_distribution_figures/*')
    # images_list.sort(key = lambda x: x[-16:-4])
    # frame_array = []
    # fps = 30
    # for img_pth in images_list:
    #     img = cv2.imread(img_pth)
    #     height, width, channels = img.shape
    #     size = (width,height)
    #     #inserting the frames into an image array
    #     frame_array.append(img)
    #     out = cv2.VideoWriter(f'plot.avi',cv2.VideoWriter_fourcc(*'DIVX'), fps, size)
    #     for i in range(len(frame_array)):
    #         # writing to a image array
    #         out.write(frame_array[i])
    # out.release()