All_Installs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1/17/2021-1\n",
    "from __future__ import absolute_import, division\n",
    "from IPython.display import clear_output\n",
    "from BashColors import C\n",
    "\n",
    "import glob, os, shutil\n",
    "from os.path import *\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' \n",
    "\n",
    "import TarfileFunctions\n",
    "from TarfileFunctions import *\n",
    "from BashColors import C\n",
    "\n",
    "contentPath=os.getcwd()\n",
    "if exists(join(contentPath, 'site')):\n",
    "    shutil.rmtree(join(contentPath, 'site'))\n",
    "cv2Path = join(contentPath, 'CV2Images')\n",
    "testPath = join(contentPath, 'images')\n",
    "\n",
    "if not exists(cv2Path):\n",
    "    try: tff.extractTarfiles('All_CV2_Images.tar.gz')\n",
    "    except FileNotFoundError as err:\n",
    "        print(err)\n",
    "        \n",
    "try: \n",
    "    import tensorflow as tf\n",
    "    print(f'tensorflow: {C.BIBlue}{tf.__version__}{C.ColorOff}')\n",
    "except ModuleNotFoundError as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install tensorflow\n",
    "    import tensorflow as tf\n",
    "\n",
    "try: \n",
    "    import tensorflow_hub as hub\n",
    "    print(f'hub: {C.BIBlue}{hub.__version__}{C.ColorOff}')\n",
    "except Exception as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install --upgrade tensorflow-hub\n",
    "    import tensorflow_hub as hub\n",
    "\n",
    "try:\n",
    "    import tflite_model_maker\n",
    "    print(f'tflite: {C.BIBlue}{tflite_model_maker.__version__}{C.ColorOff}')\n",
    "except Exception as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install tflite-model-maker\n",
    "    import tflite_model_maker\n",
    "\n",
    "try: \n",
    "    import numpy as np\n",
    "    print(f'numpy: {C.BIBlue}{np.__version__}{C.ColorOff}')\n",
    "except ModuleNotFoundError as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install numpy\n",
    "    import numpy as np\n",
    "\n",
    "try: \n",
    "    import cv2\n",
    "    from cv2 import COLOR_BGR2RGBA, IMREAD_UNCHANGED\n",
    "    print(f'cv2: {C.BIBlue}{cv2.__version__}{C.ColorOff}')\n",
    "except ModuleNotFoundError as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install opencv-python-headless # works.\n",
    "    # %pip install opencv-contrib-python-headless\n",
    "    import cv2\n",
    "    from cv2 import COLOR_BGR2RGBA, IMREAD_UNCHANGED\n",
    "\n",
    "try:\n",
    "    import matplotlib\n",
    "    from matplotlib import pyplot as plt\n",
    "    print(f'matplotlib: {C.BIBlue}{matplotlib.__version__}{C.ColorOff}')\n",
    "except Exception as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install matplotlib\n",
    "    import matplotlib\n",
    "    from matplotlib import pyplot as plt\n",
    "    \n",
    "try:\n",
    "    import scipy\n",
    "    print(f'scipy: {C.BIBlue}{scipy.__version__}')\n",
    "except ModuleNotFoundError as err:\n",
    "    print(f'\\n{C.BIRed}{err}{C.ColorOff}\\n')\n",
    "    %pip install SciPy\n",
    "    import scipy\n",
    "    \n",
    "import CV2_Utils\n",
    "from CV2_Utils import *\n",
    "\n",
    "print(C.BIRed)\n",
    "print(\"GPU is\", \"available\" if tf.config.list_physical_devices('GPU') else \"NOT AVAILABLE\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tff.inspectTarfile('Defcon_Images.tar.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contentPath = os.getcwd()\n",
    "tfImagesPath = join(contentPath, 'TensorflowImages')\n",
    "try: tff.extractTarfiles('Defcon_Images.tar.gz')\n",
    "except FileNotFoundError as err: print(err)\n",
    "\n",
    "list = glob.glob('**', recursive=True)\n",
    "dst='Validation'\n",
    "src=join('/home/jovyan/TensorflowImages/FriendlyValidation')\n",
    "for path in sorted(list):\n",
    "    fullPath=abspath(path)\n",
    "    if isdir(fullPath):\n",
    "        # print(f'{C.IBlue}{fullPath}{C.ColorOff}')\n",
    "        if not exists(dst):\n",
    "            shutil.copytree(src, dst,\n",
    "                            symlinks=False,\n",
    "                            ignore=None,\n",
    "                            copy_function=shutil.copy2,\n",
    "                            ignore_dangling_symlinks=False)\n",
    "        else:\n",
    "            valPath=join(contentPath,dst)\n",
    "            os.chdir(valPath)\n",
    "            sleep(1)\n",
    "            os.chdir(contentPath)\n",
    "\n",
    "if exists(tfImagesPath):\n",
    "            print(f'{C.IRed}{tfImagesPath}{C.ColorOff}')\n",
    "            shutil.rmtree(tfImagesPath)\n",
    "else: pass\n",
    "\n",
    "list=glob.glob('**')\n",
    "for path in list:\n",
    "    fullPath=abspath(path)\n",
    "    if fullPath.endswith('.png')and fullPath.__contains__('validation'):\n",
    "        print(fullPath)\n",
    "        img=cvu.loadCV2Image(fullPath)\n",
    "        img=cvu.resizeImage(img)\n",
    "        cv2.imwrite(fullPath, img)\n",
    "        cvu.plotShowSingleImage(img, title1=basename(fullPath))\n",
    "        sleep(1)\n",
    "        print(img.shape)\n",
    "        img=None\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "enemyPath=join(contentPath, 'data/EnemyTraining')\n",
    "enemyValidationPath=join(contentPath, 'data/EnemyValidation')\n",
    "\n",
    "if not exists(enemyPath):\n",
    "    os.makedirs(enemyPath)\n",
    "os.chdir(contentPath)\n",
    "\n",
    "if not exists(enemyValidationPath):\n",
    "    os.makedirs(enemyValidationPath)\n",
    "    \n",
    "friendlyPath=join(contentPath, 'data/FriendlyTraining')\n",
    "friendlyValidationPath=join(contentPath, 'data/FriendlyValidation')\n",
    "\n",
    "if not exists(friendlyPath):\n",
    "    os.makedirs(friendlyPath)\n",
    "os.chdir(contentPath)\n",
    "\n",
    "if not exists(friendlyValidationPath):\n",
    "    os.makedirs(friendlyValidationPath)\n",
    "\n",
    "os.chdir(contentPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glist=glob.glob('**', recursive=True)\n",
    "for directory in sorted(glist):\n",
    "    fullPath=abspath(directory)\n",
    "    if isdir(fullPath) and fullPath.__contains__('data'):\n",
    "        print(f'{C.BIBlue}{fullPath}')\n",
    "        print(fullPath)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "globList = glob.glob('**', recursive=True)\n",
    "enemyCount=0\n",
    "friendlyCount=0\n",
    "print(len(globList), 'files\\n')\n",
    "for pth in sorted(globList):\n",
    "    fullPath=abspath(pth)\n",
    "    # print(fullPath)\n",
    "    if not isdir(fullPath):\n",
    "        if fullPath.__contains__('enemy'):\n",
    "            enemyCount+=1\n",
    "            print(f'{enemyCount}. {C.BIPurple}{fullPath}{C.ColorOff}')\n",
    "        elif fullPath.__contains__('friendly'):\n",
    "            friendlyCount+=1\n",
    "            print(f'{friendlyCount}. {C.BIGreen}{fullPath}{C.ColorOff}')\n",
    "            \n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imagePathList=[]\n",
    "resize=(224, 224)\n",
    "\n",
    "for pth in sorted(globList):\n",
    "    fullPath=abspath(pth)\n",
    "    if isfile(fullPath):\n",
    "        imagePathList.append(fullPath)\n",
    "        # print(fullPath)\n",
    "\n",
    "print(len(imagePathList), 'images\\n')\n",
    "for pth in sorted(imagePathList):\n",
    "    if pth.__contains__('enemy'):\n",
    "        savePath=join(enemyPath, basename(pth))\n",
    "        print(f'savePath: {C.BIGreen}{savePath}{C.ColorOff}')\n",
    "        newImg=cv2.imread(pth, cv2.IMREAD_COLOR)\n",
    "        newImg=cv2.resize(src=newImg, dsize=resize)\n",
    "        print(newImg.shape)\n",
    "        # cvu.plotShowSingleImage(newImg, title1=basename(pth))\n",
    "        sleep(0.2)\n",
    "        if not exists(savePath):\n",
    "            cv2.imwrite(savePath, newImg)\n",
    "            sleep(0.2)\n",
    "        newImg=None\n",
    "sleep(2)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for pth in sorted(imagePathList):\n",
    "    if pth.__contains__('friendly'):\n",
    "        savePath=join(friendlyPath, basename(pth))\n",
    "        print(f'savePath: {C.BIGreen}{savePath}{C.ColorOff}')\n",
    "        newImg=cv2.imread(pth, cv2.IMREAD_COLOR)\n",
    "        newImg=cv2.resize(src=newImg, dsize=resize)\n",
    "        print(newImg.shape)\n",
    "        # cvu.plotShowSingleImage(newImg, title1=basename(pth))\n",
    "        sleep(0.2)\n",
    "        if not exists(savePath):\n",
    "            cv2.imwrite(savePath, newImg)\n",
    "            sleep(0.2)\n",
    "        newImg=None\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(enemyPath)\n",
    "glist=[]\n",
    "glist=glob.glob('**', recursive=True)\n",
    "glist=sorted(glist)\n",
    "print(len(glist), 'files\\n')\n",
    "\n",
    "for pth in glist:\n",
    "    fullPath=abspath(pth)\n",
    "    # print(fullPath)\n",
    "print()\n",
    "\n",
    "for item in glist[21:len(glist)]:\n",
    "    fullPath=abspath(item)\n",
    "    copyToPath=join(enemyValidationPath, item)\n",
    "    \n",
    "    if not exists(copyToPath):\n",
    "        shutil.move(fullPath, copyToPath)\n",
    "        print(item)\n",
    "        print(f'{C.BIGreen}{copyToPath}{C.ColorOff}')\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(friendlyPath)\n",
    "moveCount=0\n",
    "glist=[]\n",
    "glist=glob.glob('**', recursive=True)\n",
    "glist=sorted(glist)\n",
    "print(len(glist), 'files\\n')\n",
    "\n",
    "for pth in glist:\n",
    "    fullPath=abspath(pth)\n",
    "    # print(fullPath)\n",
    "print()\n",
    "\n",
    "for item in glist[172:len(glist)]:\n",
    "    fullPath=abspath(item)\n",
    "    copyToPath=join(friendlyValidationPath, item)\n",
    "    \n",
    "    if not exists(copyToPath):\n",
    "        moveCount+=1\n",
    "        shutil.move(fullPath, copyToPath)\n",
    "        print(moveCount,item)\n",
    "        print(f'{C.BIGreen}{copyToPath}{C.ColorOff}')\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "testPath=join(contentPath, 'images/TestImages')\n",
    "if exists(testPath):\n",
    "    shutil.rmtree(testPath)\n",
    "    sleep(0.2)\n",
    "if not exists(testPath):\n",
    "    os.makedirs(testPath)\n",
    "    print(f'creating: {C.BIPurple}{testPath}')\n",
    "else: print(f'exists: {C.BIGreen}{testPath}')\n",
    "testCount=0\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def renameImage(path, count):\n",
    "    # testPath=join(contentPath, 'TestImages')\n",
    "    fullPath=path\n",
    "    name=basename(fullPath)\n",
    "    # print(name)\n",
    "    newName='test_00' + str(count) + '.png'\n",
    "    renamePath=join(testPath, newName)\n",
    "    \n",
    "    print(renamePath)\n",
    "    # os.rename(fullPath, renamePath)\n",
    "    return renamePath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(contentPath)\n",
    "globList=[]\n",
    "globList=glob.glob('**')\n",
    "for item in sorted(globList):\n",
    "    fullPath=abspath(item)\n",
    "    if item.endswith('.jpg'):\n",
    "        print(fullPath)\n",
    "        img=cvu.loadCV2Image(fullPath)\n",
    "        img=cvu.resizeImage(img)\n",
    "        newImg=np.copy(img)\n",
    "        # savePath=join(contentPath, 'test_0071.png')\n",
    "        testCount+=1\n",
    "        savePath=renameImage(fullPath, testCount)\n",
    "        if not exists(savePath):\n",
    "            cv2.imwrite(savePath, newImg)\n",
    "        print(img.shape)\n",
    "        # cvu.plotShowSingleImage(newImg, title1=basename(savePath))\n",
    "        sleep(0.2)\n",
    "        img=None\n",
    "        newImg=None\n",
    "\n",
    "globList=[]\n",
    "globList=glob.glob('**')\n",
    "for item in sorted(globList):\n",
    "    fullPath=abspath(item)\n",
    "    \n",
    "    if isdir(fullPath) and fullPath.__contains__('Validation'):\n",
    "        pass\n",
    "        # print(f'{C.BIBlue}{fullPath}{C.ColorOff}')\n",
    "        \n",
    "    elif isfile(fullPath) and fullPath.endswith('.png'):\n",
    "        # print(fullPath)\n",
    "        img = cv2.imread(fullPath, cv2.IMREAD_COLOR)\n",
    "        newImg=np.copy(img)\n",
    "        testCount+=1\n",
    "        savePath=renameImage(fullPath, testCount)\n",
    "        if not exists(savePath):\n",
    "            cv2.imwrite(savePath, newImg)\n",
    "            sleep(0.2)\n",
    "        # cvu.plotShowSingleImage(newImg, title1=basename(savePath))\n",
    "        print(img.shape)\n",
    "        sleep(0.2)\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savePath = join(contentPath, 'DataGenerator')\n",
    "if exists(savePath):\n",
    "    print(f'removing: {C.BIRed}{savePath}')\n",
    "    shutil.rmtree(savePath)\n",
    "    sleep(0.1)\n",
    "else: print(f'removed: {C.BIRed}{savePath}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
    "\n",
    "datagen = ImageDataGenerator(\n",
    "    rescale= 1./255,\n",
    "    zoom_range=-0.45,\n",
    "    rotation_range=45,\n",
    "    shear_range=0.1,\n",
    "    width_shift_range=0.1,\n",
    "    height_shift_range=0.1,\n",
    "    vertical_flip=True,\n",
    "    horizontal_flip=True,\n",
    "    fill_mode='nearest')\n",
    "    # rotation_range=50,\n",
    "    # width_shift_range=0.1,\n",
    "    # height_shift_range=0.1,\n",
    "    # rescale=1./255,\n",
    "    # shear_range=0.1,\n",
    "    # zoom_range=-0.5,\n",
    "    # horizontal_flip=True,\n",
    "    # vertical_flip=True,\n",
    "    # fill_mode='nearest')\n",
    "\n",
    "savePath = join(contentPath, 'DataGenerator/Enemy')\n",
    "if not exists(savePath):\n",
    "    os.makedirs(savePath)\n",
    "enemyPath= join(cv2Path, 'Enemy')\n",
    "os.chdir(enemyPath)\n",
    "globList=[]\n",
    "globList = glob.glob('**', recursive=True)\n",
    "print(len(globList))\n",
    "\n",
    "for pth in sorted(globList):\n",
    "    fullPath = abspath(pth)\n",
    "    # print(fullPath)\n",
    "    filePath = fullPath\n",
    "    fileName = basename(fullPath)\n",
    "    fileSplit = split(basename(fullPath))\n",
    "    fileSplit = splitext(fileSplit[1])\n",
    "    baseFileName =fileSplit[0]\n",
    "    fileExtension = fileSplit[1]\n",
    "    print(fileName, baseFileName, fileExtension)\n",
    "\n",
    "    img = load_img(fileName)  # this is a PIL image\n",
    "    x = img_to_array(img)  # numpy array with shape (3, 224, 224)\n",
    "    x = x.reshape((1,) + x.shape)\n",
    "    print(x.shape)\n",
    "    # this is a Numpy array with shape (1, 3, 224, 224)\n",
    "    # .flow() command generates batches of randomly transform images\n",
    "    # and saves the results to the `DataGenerator/` directory\n",
    "    i = 0\n",
    "    for batch in datagen.flow(x, batch_size=1,\n",
    "                              save_to_dir=savePath,\n",
    "                              save_prefix=baseFileName,\n",
    "                              save_format='png'):\n",
    "        i += 1\n",
    "        sleep(0.25)\n",
    "        if i > 14:\n",
    "            break  # otherwise the generator would loop indefinitely\n",
    "clear_output()\n",
    "\n",
    "savePath = join(contentPath, 'DataGenerator/Enemy')\n",
    "os.chdir(savePath)\n",
    "globList=[]\n",
    "globList = glob.glob('**', recursive=True)\n",
    "print(len(globList), 'enemy files')\n",
    "\n",
    "os.chdir(contentPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
    "\n",
    "datagen = ImageDataGenerator(rescale= 1./255)\n",
    "    # rescale=1./255,\n",
    "    # rotation_range=50,\n",
    "    # width_shift_range=0.1,\n",
    "    # height_shift_range=0.1,\n",
    "    # shear_range=0.1,\n",
    "    # zoom_range=-0.5,\n",
    "    # horizontal_flip=True,\n",
    "    # vertical_flip=True,\n",
    "    # fill_mode='nearest')\n",
    "\n",
    "savePath = join(contentPath, 'DataGenerator/Friendly')\n",
    "if not exists(savePath):\n",
    "    os.makedirs(savePath)\n",
    "friendlyPath= join(cv2Path, 'Friendly')\n",
    "os.chdir(friendlyPath)\n",
    "globList=[]\n",
    "globList = glob.glob('**', recursive=True)\n",
    "print(len(globList))\n",
    "                     \n",
    "for pth in sorted(globList):\n",
    "    fullPath = abspath(pth)\n",
    "    # print(fullPath)\n",
    "    filePath = fullPath\n",
    "    fileName = basename(fullPath)\n",
    "    fileSplit = split(basename(fullPath))\n",
    "    fileSplit = splitext(fileSplit[1])\n",
    "    baseFileName =fileSplit[0]\n",
    "    fileExtension = fileSplit[1]\n",
    "    print(fileName, baseFileName, fileExtension)\n",
    "\n",
    "    img = load_img(fileName)  # this is a PIL image\n",
    "    x = img_to_array(img)  # numpy array with shape (3, 224, 224)\n",
    "    x = x.reshape((1,) + x.shape)\n",
    "    print(x.shape)\n",
    "    # this is a Numpy array with shape (1, 3, 224, 224)\n",
    "    # .flow() command generates batches of randomly transform images\n",
    "    # and saves the results to the `DataGenerator/` directory\n",
    "    i = 0\n",
    "    for batch in datagen.flow(x, batch_size=1,\n",
    "                              save_to_dir=savePath,\n",
    "                              save_prefix=baseFileName,\n",
    "                              save_format='png'):\n",
    "        i += 1\n",
    "        sleep(0.25)\n",
    "        if i > 1:\n",
    "            break  # otherwise the generator would loop indefinitely\n",
    "clear_output()\n",
    "\n",
    "# savePath = join(contentPath, 'DataGenerator')\n",
    "os.chdir(savePath)\n",
    "globList=[]\n",
    "globList = glob.glob('**', recursive=True)\n",
    "print(len(globList), 'friendly files')\n",
    "for fil in sorted(globList):\n",
    "    pass\n",
    "    # print(abspath(fil))\n",
    "os.chdir(contentPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(contentPath)\n",
    "globList=[]\n",
    "globList=glob.glob('**', recursive=True)\n",
    "\n",
    "for pth in globList:\n",
    "    fullPath = abspath(pth)\n",
    "    if fullPath.__contains__('validation') and fullPath.endswith('.png'):\n",
    "        # print(fullPath)\n",
    "        destinationPath = join(testPath)\n",
    "        destinationPath = join(destinationPath, basename(fullPath))\n",
    "        if not exists(destinationPath):\n",
    "            sourcePath = fullPath\n",
    "            print(f'{C.BIRed}{sourcePath}')\n",
    "            print(f'{C.BIGreen}{destinationPath}\\n')\n",
    "            shutil.copy2(sourcePath, destinationPath)\n",
    "        if exists(destinationPath):\n",
    "            print(f'{C.BIGreen}{destinationPath}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(testPath)\n",
    "globList=[]\n",
    "globList=glob.glob('**')\n",
    "print(len(globList))\n",
    "for pth in globList:\n",
    "    fullPath=abspath(pth)\n",
    "    print(fullPath)\n",
    "    if fullPath.endswith('.png'):\n",
    "        fullPath=abspath(pth)\n",
    "        # img=cvu.loadCV2Image(fullPath)\n",
    "        img = cv2.imread(fullPath, cv2.IMREAD_COLOR)\n",
    "        img = cv2.resize(img, dsize=(224, 224))\n",
    "        cv2.imwrite(fullPath, img)\n",
    "        newImg = cv2.imread(fullPath, cv2.IMREAD_COLOR)\n",
    "        cvu.plotShowSingleImage(newImg, title1=basename(fullPath))\n",
    "        sleep(0.5)\n",
    "        img=None\n",
    "        newImg=None\n",
    "os.chdir(contentPath)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "New-Notebook",
   "private_outputs": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}