CV2_Write_Images.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stuffed-economics",
   "metadata": {
    "id": "stuffed-economics"
   },
   "outputs": [],
   "source": [
    "# 11/3/2021-1\n",
    "from __future__ import absolute_import\n",
    "from IPython.display import clear_output\n",
    "import glob, os, shutil, sys\n",
    "from os.path import *\n",
    "from time import sleep\n",
    "\n",
    "tfImagesPath=None\n",
    "cv2ImagePathList=[]\n",
    "\n",
    "try:\n",
    "    from google.colab import drive, files\n",
    "    from google.colab.patches import cv2_imshow\n",
    "except Exception as err:\n",
    "    pass\n",
    "\n",
    "try: \n",
    "    from matplotlib import pyplot as plt\n",
    "except Exception as err:\n",
    "    %pip install matplotlib\n",
    "    from matplotlib import pyplot as plt\n",
    "\n",
    "try: \n",
    "    import cv2\n",
    "    from cv2 import COLOR_BGR2RGBA\n",
    "except Exception as err:\n",
    "    print(err)\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: import tensorflow as tf\n",
    "except Exception as err:\n",
    "    # print(err)\n",
    "    %pip install tensorflow\n",
    "    import tensorflow as tf\n",
    "    \n",
    "import numpy as np\n",
    "\n",
    "if exists('/content/sample_data'):\n",
    "    shutil.rmtree('/content/sample_data')\n",
    "\n",
    "contentPath = os.getcwd()\n",
    "tfImagesPath = join(contentPath, 'TensorflowImages')\n",
    "resizedImagesPath = join(contentPath, 'TensorflowResizedImages')\n",
    "\n",
    "if exists(resizedImagesPath):\n",
    "    pass\n",
    "    # shutil.rmtree(resizedImagesPath)\n",
    "\n",
    "try:\n",
    "    drive.flush_and_unmount()\n",
    "    drive.mount('/content/gdrive/', force_remount=True)\n",
    "    mydrivePth = '/content/gdrive/MyDrive'\n",
    "    os.chdir(mydrivePth)\n",
    "    gdriveTFImagesPth = join(mydrivePth, 'TensorflowImages')\n",
    "    gdriveResizedImagesPth = join(mydrivePth, 'TensorflowResizedImages')\n",
    "    \n",
    "    os.chdir(mydrivePth)\n",
    "    try:\n",
    "        import TarfileFunctions\n",
    "        from TarfileFunctions import *\n",
    "    except Exception as err: print(err)\n",
    "\n",
    "    from BashColors import C\n",
    "    copyPath = join(mydrivePth, 'BashColors.py')\n",
    "    if exists(copyPath):\n",
    "        shutil.copy2(copyPath, contentPath)\n",
    "    \n",
    "    if not exists(tfImagesPath):\n",
    "        shutil.copytree(gdriveTFImagesPth, tfImagesPath)\n",
    "        # tff.listTarfiles()\n",
    "        os.chdir(contentPath)\n",
    "        # tff.extractTarfiles('Juno_Original_Images.tar.gz')\n",
    "\n",
    "    gdrive_resized_images = '/content/gdrive/MyDrive/TensorflowResizedImages'\n",
    "    if not exists(resizedImagesPath):\n",
    "        try: \n",
    "            pass\n",
    "            # shutil.copytree(gdrive_resized_images, resizedImagesPath)\n",
    "        except Exception as err:\n",
    "            print(err)\n",
    "    os.chdir(contentPath)\n",
    "\n",
    "except Exception as err:\n",
    "    # print(err)\n",
    "    os.chdir(contentPath)\n",
    "    from TarfileFunctions import *\n",
    "    from BashColors import C\n",
    "    tarfilePath=join(contentPath, 'New_Juno_Original_Images.tar.gz')\n",
    "    if exists(tarfilePath) and not exists(tfImagesPath):\n",
    "        tff.extractTarfiles('New_Juno_Original_Images.tar.gz')\n",
    "\n",
    "rootPth = expanduser(\"~\")\n",
    "\n",
    "tfImagesPath = join(contentPath, 'TensorflowImages')\n",
    "resizedImagesPath = join(contentPath, 'TensorflowResizedImages')\n",
    "\n",
    "os.chdir(tfImagesPath)\n",
    "tfImageGlob = glob.glob('**', recursive=True)\n",
    "\n",
    "os.chdir(contentPath)\n",
    "cv2Path = join(contentPath, 'CV2Images')\n",
    "cv2EnemyPath = join(cv2Path, 'Enemy')\n",
    "cv2FriendlyPath = join(cv2Path, 'Friendly')\n",
    "\n",
    "if exists(cv2Path):\n",
    "    shutil.rmtree(cv2Path)\n",
    "\n",
    "if not exists(cv2Path):\n",
    "    os.mkdir(cv2Path)\n",
    "    os.mkdir(cv2EnemyPath)\n",
    "    os.mkdir(cv2FriendlyPath)\n",
    "\n",
    "os.chdir(contentPath)\n",
    "clear_output()\n",
    "print(f'tensorflow: {C.IBlue}{tf.__version__}{C.ColorOff}')\n",
    "print(f'cv2: {C.IBlue}{cv2.__version__}{C.ColorOff}')\n",
    "print(f'cwd: {C.IBlue}{os.getcwd()}{C.ColorOff}')\n",
    "print(f'rootPth: {C.IBlue}{rootPth}{C.ColorOff}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d4ee5d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile CV2_Utils.py\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import glob, os, uuid\n",
    "from os.path import *\n",
    "from time import sleep\n",
    "from BashColors import C\n",
    "\n",
    "class CV2_Utils:\n",
    "    ''' '''\n",
    "    __all__ = ['cvu','rootPth','contentPath','tfImagesPth','cv2ImagesPth',\n",
    "               'cv2ImagePathList','tfImagePathList',\n",
    "               'originalImageZeroPixel', 'zeroPixel']\n",
    "    # __builtin__ = []\n",
    "\n",
    "    def __init__(self):\n",
    "        ''' '''\n",
    "        self.cvu = CV2_Utils\n",
    "\n",
    "        self.rootPth = expanduser(\"~\")\n",
    "        self.contentPath = os.getcwd()\n",
    "        self.tfImagesPth = join(os.getcwd(), 'TensorflowImages')\n",
    "        self.cv2ImagesPth = join(os.getcwd(), 'CV2Images')\n",
    "\n",
    "        self.zeroPixel = np.ndarray([0, 0, 0, 0])\n",
    "        self.originalImageZeroPixel = np.ndarray([0, 0, 0, 0])\n",
    "\n",
    "    def __iter__(self):\n",
    "         ''' '''\n",
    "         for key in self.some_sequence:\n",
    "            yield (key, 'Value for {}'.format(key))\n",
    "            \n",
    "    def flipImage2(self, thisImage, axes):\n",
    "        '''hflp = flip(img, 0)\\nvflp = flip(img, 1)\\nbflp = flip(img,-1)'''\n",
    "        if (axes == 0): # horizental flip\n",
    "            print('hflp')\n",
    "            return cv2.flip(thisImage, 0 )\n",
    "        elif(axes == 1): # vertical flip\n",
    "            print('vflp')\n",
    "            return cv2.flip(thisImage, 1 )\n",
    "        elif(axes == -1): # both directions\n",
    "            print('bflp')\n",
    "            return cv2.flip(thisImage, -1 )\n",
    "        \n",
    "    def saveCV2Image(self, path, img):\n",
    "        cv2.imwrite(path, img)\n",
    "        \n",
    "    def loadCV2Image(self, path):\n",
    "        '''IMREAD_UNCHANGED'''\n",
    "        img=cv2.imread(path, cv2.IMREAD_UNCHANGED)\n",
    "        return img\n",
    "    \n",
    "    def getCV2SavePath(self, path, append='', silent=True):\n",
    "        ''' '''\n",
    "        fileName=basename(path)\n",
    "        fileName=fileName.replace('_', '')\n",
    "        splitFileName=splitext(fileName)\n",
    "        if append != '':\n",
    "            fileName = splitFileName[0] + append + splitFileName[1]\n",
    "\n",
    "        if path.__contains__('enemy'):\n",
    "            newPath=join('/home/jovyan/CV2Images/Enemy/', fileName)\n",
    "            if not silent:\n",
    "                print(f'{C.IPurple}{path}')\n",
    "                print(f'{C.IPurple}{fileName}')\n",
    "                print(f'newPath: {C.Green}{newPath}{C.ColorOff}\\n')\n",
    "            return newPath\n",
    "        \n",
    "        elif path.__contains__('friendly'):\n",
    "            newPath=join('/home/jovyan/CV2Images/Friendly/', fileName)\n",
    "            if not silent:\n",
    "                print(f'{C.IPurple}{path}')\n",
    "                print(f'{C.IPurple}{fileName}')\n",
    "                print(f'newPath: {C.Green}{newPath}{C.ColorOff}\\n')\n",
    "            return newPath\n",
    "\n",
    "    def listCV2Images(self):\n",
    "        cwd=os.getcwd()\n",
    "        os.chdir(self.cv2ImagesPth)\n",
    "        globList=glob.glob('**', recursive=True)\n",
    "        for fil in sorted(globList):\n",
    "            fullPath=abspath(fil)\n",
    "            if fullPath.endswith('.png'):\n",
    "                print(fullPath)\n",
    "        os.chdir(cwd)\n",
    "        \n",
    "    def fillImage3(self, thisImage, zp, silent=True):\n",
    "        ''' '''\n",
    "        if zp == np.ndarray([64,64,64,255]):\n",
    "            pass\n",
    "        original_image = np.copy(thisImage)\n",
    "        img = np.copy(original_image)\n",
    "\n",
    "        black = np.where((img[:,:,0]==0) & (img[:,:,1]==0) & (img[:,:,2]==0))\n",
    "\n",
    "        white = np.where((img[:,:,0]==255) & (img[:,:,1]==255) & (img[:,:,2]==255))\n",
    "\n",
    "        img[black] = (zp[0], zp[1], zp[2], zp[3])\n",
    "        img[white] = (0, 0, 0, 0)\n",
    "\n",
    "        if not silent:\n",
    "            cvu.showTwoImages(original_image, img)\n",
    "        return img\n",
    "\n",
    "    def resizeImage(self, thisImage, newSize=(224,224)):\n",
    "        '''return resized_image'''\n",
    "        resized_image = cv2.resize(thisImage, newSize,\n",
    "                                   interpolation=cv2.INTER_CUBIC)\n",
    "        return resized_image\n",
    "\n",
    "    def createCV2ImagesTarfile(self):\n",
    "        ''' '''\n",
    "        os.chdir(self.cv2ImagesPth)\n",
    "        from TarfileFunctions import tff, tarfileFromDirectory\n",
    "        thisDir = cvu.cv2ImagesPth\n",
    "        if exists(thisDir):\n",
    "            # print(thisDir)\n",
    "            try: tff.tarfileFromDirectory(output_filename='CV2Images.tar.gz',\n",
    "                                          source_dir=thisDir)\n",
    "            except BaseException as err: print(err)\n",
    "\n",
    "    def renameFileWithPath(self, path, append=''):\n",
    "        '''return newPath'''\n",
    "        file_path, extension = path.split('.')\n",
    "        # print(f'file_path: {file_path}')\n",
    "        # print(f'extension: {extension}')\n",
    "        newPath = file_path + append + '.' + extension\n",
    "        newPath = join(newPath)\n",
    "        \n",
    "        return newPath\n",
    "        \n",
    "    def showTwoImages(self, img1, img2):\n",
    "        '''display two images with  CV2'''\n",
    "        img1 = self.resizeImage(img1)\n",
    "        img2 = self.resizeImage(img2)\n",
    "        combinedImage = cv2.hconcat([img1, img2])\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "            cv2_imshow(combinedImage)\n",
    "        except: \n",
    "            self.plotShowSingleImage(img1, img2)\n",
    "\n",
    "    def plotShowSingleImage(self, thisImage, title1='', showAxis=False):\n",
    "        ''' '''\n",
    "        thisImage = cv2.cvtColor(thisImage, cv2.COLOR_BGR2RGBA)\n",
    "\n",
    "        fig=plt.figure()\n",
    "        ax1=fig.add_subplot(1,1,1)\n",
    "        ax1.imshow(thisImage)\n",
    "        if showAxis: ax1.axis('on')\n",
    "        else: ax1.axis('off')\n",
    "        ax1.set_title(title1)\n",
    "        plt.show()\n",
    "\n",
    "    def plotShowTwoImages(self, thisImage, compareImage,\n",
    "                                title1='Original Image',\n",
    "                                title2='', showAxis=False):\n",
    "        ''' '''\n",
    "        thisImage = cv2.cvtColor(thisImage, cv2.COLOR_BGR2RGBA)\n",
    "        compareImage = cv2.cvtColor(compareImage, cv2.COLOR_BGR2RGBA)\n",
    "\n",
    "        fig=plt.figure()\n",
    "        ax1 = fig.add_subplot(1,2,1)\n",
    "        ax1.imshow(thisImage)\n",
    "        if showAxis: ax1.axis('on')\n",
    "        else: ax1.axis('off')\n",
    "        ax1.set_title(title1)\n",
    "\n",
    "        ax2 = fig.add_subplot(1,2,2)\n",
    "        ax2.imshow(compareImage)\n",
    "        if showAxis: ax2.axis('on')\n",
    "        else: ax2.axis('off')\n",
    "        ax2.set_title(title2)\n",
    "        plt.show()\n",
    "\n",
    "    def createImageWithColor(self, pxColor, silent=True):\n",
    "        '''return save_path'''\n",
    "        bgImage = np.zeros(shape=[224,224,4], dtype=np.uint8)\n",
    "        save_path = join(self.contentPath, 'bgImage.png')\n",
    "\n",
    "        for px in bgImage:\n",
    "            bgImage[:] = pxColor\n",
    "            sleep(0.1)\n",
    "\n",
    "        cv2.imwrite(save_path, bgImage)\n",
    "        \n",
    "        if not silent:\n",
    "            print(f'shape: {bgImage.shape}')\n",
    "            bgImage = cv2.imread(save_path, cv2.IMREAD_UNCHANGED)\n",
    "            try:\n",
    "                cv2_imshow(bgImage)\n",
    "                cv2.waitKey(50)\n",
    "                cv2.destroyAllWindows()\n",
    "            except:\n",
    "                self.plotShowSingleImage(bgImage)\n",
    "        return save_path\n",
    "\n",
    "    def zoomImage(self, thisImage, newScale=1, silent=True):\n",
    "        '''return zoomImage'''\n",
    "        zeroPixel = thisImage[0][0]\n",
    "        angle = 0\n",
    "        width, height, _ = thisImage.shape\n",
    "        rotPoint = width//2, height //2\n",
    "        dimentions = width, height\n",
    "        rotPoint = width//2, height//2\n",
    "        rotMatrix = cv2.getRotationMatrix2D(rotPoint, angle, scale=newScale)\n",
    "        zoomImage = cv2.warpAffine(thisImage, rotMatrix, dimentions)\n",
    "        zoomImage = self.cv2FillImage(zoomImage)\n",
    "        if not silent:\n",
    "            print('cv2ZoomImage()')\n",
    "            self.plotCompareTwoImages(thisImage, zoomImage)\n",
    "        return zoomImage\n",
    "\n",
    "    def rotateImage(self, thisImage, angle=0, rotPoint=None,\n",
    "                    newScale=1, silent=True):\n",
    "        '''return rotImage'''\n",
    "        thisImage = np.copy(thisImage)\n",
    "        # self.originalImageZeroPixel = thisImage[0, 0]\n",
    "        # print(thisImage.shape)\n",
    "        width, height, _ = thisImage.shape\n",
    "        if rotPoint == None:\n",
    "            rotPoint = width//2, height//2\n",
    "            rotMat = cv2.getRotationMatrix2D(rotPoint, angle, scale=newScale)\n",
    "            dimentions = width, height\n",
    "            rotImage = cv2.warpAffine(thisImage, rotMat, dimentions)\n",
    "            # rotImageZeroPixel = rotImage[0][0]\n",
    "            if not silent:\n",
    "                print('cv2Rotation()')\n",
    "                self.plotShowTwoImages(thisImage, rotImage)\n",
    "                sleep(0.1)\n",
    "            try:\n",
    "                cv2.waitKey(50)\n",
    "                cv2.destroyAllWindows()\n",
    "            except:\n",
    "                sleep(0.05)\n",
    "                \n",
    "            return rotImage\n",
    "\n",
    "    def translateImage(self, thisImage, x=0, y=0, silent=True):\n",
    "        '''-x shift left -y shift up\\nx shift right y shift down\\n\n",
    "        return newImage'''\n",
    "        thisImage = np.copy(thisImage)\n",
    "        zeroPixel=thisImage[0][0]\n",
    "        translateMatrix = np.float32([[1,0,x],[0,1,y]])\n",
    "        dimentions = (thisImage.shape[1], thisImage.shape[0])\n",
    "        newImage = cv2.warpAffine(thisImage, translateMatrix, dimentions)\n",
    "\n",
    "        if not silent:\n",
    "            print('cv2Translate()')\n",
    "            self.plotCompareTwoImages(thisImage, newImage)\n",
    "\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except: pass\n",
    "        return newImage\n",
    "\n",
    "    def edgeDetection(self, thisImage, t1=50, t2=100, silent=True):\n",
    "        '''return canny'''\n",
    "\n",
    "        # gray = cv2.cvtColor(thisImage, cv2.COLOR_BGR2GRAY)\n",
    "        # thisImage = cv2.GaussianBlur(gray,(3,3),0)\n",
    "\n",
    "        canny = cv2.Canny(thisImage, t1, t2)\n",
    "        if not silent:\n",
    "            self.plotCompareTwoImages(thisImage, canny)\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except: pass\n",
    "        return canny\n",
    "\n",
    "    def changeBackgroundColors(self, path, image=None):\n",
    "        '''returns newImg'''\n",
    "        splitPath = split(path)\n",
    "        filePath = splitPath[0]\n",
    "        fileName = splitPath[1]\n",
    "        fileName = 'new_' + fileName\n",
    "        print(filePath)\n",
    "        print(fileName)\n",
    "        saveImagePath = join(contentPath, fileName)\n",
    "\n",
    "        print(f'saveImagePath: {saveImagePath}')\n",
    "        original_image = cv2.imread(path, cv2.IMREAD_UNCHANGED)\n",
    "        originalZeroPixel = original_image[0][0]\n",
    "        plt.imshow(original_image)\n",
    "        newImg = np.copy(original_image)\n",
    "\n",
    "        zeroPixel = newImg[0][0]\n",
    "        print('newImg zeroPixel:', zeroPixel)\n",
    "        print('originalZeroPixel:', originalZeroPixel)\n",
    "\n",
    "        width, height, channels = original_image.shape\n",
    "        print(width, height, channels)\n",
    "\n",
    "        for x in range(0, width):\n",
    "            for y in range(0, height):\n",
    "                channels_xy = newImg[y][x]\n",
    "                # print(channels_xy)\n",
    "                if all(channels_xy == zeroPixel):\n",
    "                    newImg[y][x] = originalZeroPixel\n",
    "\n",
    "        cv2.imwrite(saveImagePath, newImg)\n",
    "        newImg = cv2.imread(saveImagePath, -1)\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except: pass\n",
    "        return newImg\n",
    "\n",
    "    def cv2FillImage(self, thisImage, silent=True):\n",
    "        '''returns filledImage'''\n",
    "        print('cv2FillImage')\n",
    "        # plotShowSingleImage(thisImage)\n",
    "        zp = thisImage[0][0]\n",
    "        bgImagePath = self.cv2CreateImageWithColor(pxColor=cvu.zeroPixel)\n",
    "        # print(zp)\n",
    "        img1 = np.copy(thisImage)\n",
    "        img2 = cv2.imread(bgImagePath, cv2.IMREAD_UNCHANGED)\n",
    "        filledImage = cv2.bitwise_or(img1, img2)\n",
    "        filledImage = cv2.bitwise_or(filledImage, img2)\n",
    "        if not silent:\n",
    "            self.cv2ShowTwoImages(img1, filledImage)\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except Exception as err:\n",
    "            print(err)\n",
    "            sleep(0.05)\n",
    "            img1=None\n",
    "            img2=None\n",
    "                \n",
    "        return filledImage\n",
    "\n",
    "    def addTwoImages(self, imagePath1, imagePath2, alfa=1, beta=1, gamma=0.0):\n",
    "        '''return  addImage'''\n",
    "        # read two imagePaths\n",
    "        src1 = cv2.imread(imagePath1)\n",
    "        src2 = cv2.imread(imagePath2)\n",
    "        try:\n",
    "            # add or blend the imagePaths\n",
    "            addImage = cv2.addWeighted(src1, alfa, src2, beta, gamma)\n",
    "            # save the output imagePath\n",
    "            # cv2.imwrite('image.png', dst)\n",
    "            return addImage\n",
    "        except Exception as err:\n",
    "            print(f'{C.IRed}{err}')\n",
    "\n",
    "    def flipImage(self, thisImage, axes=0, silent=True):\n",
    "        '''axes=0 flip vert\\naxes=1 flip horiz\\naxes=-1 flip vert and horiz'''\n",
    "        if axes == 0:\n",
    "            flipImg = cv2.flip(thisImage, 0)\n",
    "            if not silent:\n",
    "                print('_flipVert')\n",
    "                self.showTwoImages(thisImage, flipImg)\n",
    "        elif axes == 1:\n",
    "            flipImg = cv2.flip(thisImage, 1)\n",
    "            if not silent:\n",
    "                print('_flipHorz')\n",
    "                self.showTwoImages(thisImage, flipImg)\n",
    "        elif axes == -1:\n",
    "            flipImg = cv2.flip(thisImage, -1)\n",
    "            if not silent:\n",
    "                print('_flipVertAndHorz')\n",
    "                self.showTwoImages(thisImage, flipImg)\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except: sleep(0.1)\n",
    "        return flipImg\n",
    "\n",
    "    def getUniqueFileName(self, uniquePrefix='_'):\n",
    "        '''return uniqueName'''\n",
    "        uniqueName = uniquePrefix + str(uuid.uuid4())\n",
    "        return uniqueName\n",
    "        \n",
    "    def getNewSavePath(self, initialPath, new_path='', postfix='', silent=True):\n",
    "        ''' '''\n",
    "        if new_path=='':\n",
    "            new_path = self.cv2ImagesPth + '/'\n",
    "        \n",
    "        directory, fileName = split(initialPath)\n",
    "        # dirr, name, extension = splitext(directory)\n",
    "        # print(initialPath)\n",
    "        # print(directory)\n",
    "        # print(fileName)\n",
    "        _, subDir = split(directory)\n",
    "        name, extension = splitext(fileName)\n",
    "        # print(subDir)\n",
    "\n",
    "        if not silent:\n",
    "            print(f'{C.IWhite}')\n",
    "            print(f'newPath: {new_path}')\n",
    "            print(f'subDir: {subDir}')\n",
    "            print(f'name: {name}')\n",
    "            print(f'postfix: {postfix}')\n",
    "            print(f'extension: {extension}')\n",
    "\n",
    "        newSavePath = new_path + subDir + '/' + name + postfix + extension\n",
    "        print(f'{C.IWhite}savePath: {C.IPurple}{newSavePath}{C.ColorOff}')\n",
    "        return newSavePath\n",
    "\n",
    "    def saveImage(self, savePath, thisImage, silent=True, save=False):\n",
    "        ''' '''\n",
    "        if not silent:\n",
    "            print(f'{C.IWhite}saved to: {C.Green}{savePath}{C.ColorOff}')\n",
    "            try: cv2_imshow(thisImage)\n",
    "            except BaseException as err:\n",
    "                self.plotShowSingleImage(thisImage,\n",
    "                                            title=basename(savePath))\n",
    "\n",
    "        if save and not exists(savePath):\n",
    "            print(f'{C.IWhite}saved to: {C.Green}{savePath}{C.ColorOff}')\n",
    "            cv2.imwrite(savePath, thisImage)\n",
    "\n",
    "    def fillImage(self, thisImage, silent=True):\n",
    "        ''' '''\n",
    "        original_image = np.copy(thisImage)\n",
    "        img = np.copy(original_image)\n",
    "\n",
    "        black = np.where((img[:,:,0]==0) & \n",
    "                         (img[:,:,1]==0) & \n",
    "                         (img[:,:,2]==0))\n",
    "        \n",
    "        white = np.where((img[:,:,0]==255) & \n",
    "                         (img[:,:,1]==255) & \n",
    "                         (img[:,:,2]==255))\n",
    "        \n",
    "        img[black] = (255, 255, 255, 255)\n",
    "        img[white] = (0, 0, 0, 255)\n",
    "        \n",
    "        if not silent:\n",
    "            try:\n",
    "                cvu.showTwoImages(original_image, img)\n",
    "            except Exception as err:\n",
    "                print(err)\n",
    "        try:\n",
    "            cv2.waitKey(50)\n",
    "            cv2.destroyAllWindows()\n",
    "        except:\n",
    "            sleep(0.1)\n",
    "        return img\n",
    "\n",
    "    def rotateImagesFixed(self, thisPath, silent=True, save=False):\n",
    "        '''Rotates images 90, 180, and 270 degrees fixed increments\\n'''\n",
    "        rotationList = ['90','180','270']\n",
    "        for angleString in rotationList:\n",
    "            newAngle=float(angleString)\n",
    "            appendFileName= 'Rot' + angleString\n",
    "            originalImg = self.loadCV2Image(thisPath)\n",
    "            # originalImg = self.resizeImage(originalImg)\n",
    "            rotImage = np.copy(originalImg)\n",
    "            rotImage = self.rotateImage(rotImage, newAngle)\n",
    "            savePath=''\n",
    "            if not silent:\n",
    "                savePath = self.getCV2SavePath(thisPath,\n",
    "                                              append=appendFileName,\n",
    "                                              silent=False)\n",
    "                self.plotShowTwoImages(originalImg, rotImage,\n",
    "                                      title2=basename(savePath))\n",
    "            if save and not exists(savePath):\n",
    "                print(f'{C.ColorOff}saved to: {C.Green}{savePath}{C.ColorOff}\\n')\n",
    "                self.saveCV2Image(savePath, rotImage)\n",
    "            elif exists(savePath):\n",
    "                print(f'{C.ColorOff}file already exists : {C.IRed}{savePath}{C.ColorOff}\\n')\n",
    "                    \n",
    "cvu = CV2_Utils()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c28ebf94",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createCV2ImagesTarfile(directoryPath,\n",
    "                           fileName='All_CV2_Images.tar.gz'):\n",
    "        ''' '''\n",
    "        os.chdir(self.contentPath)\n",
    "        from TarfileFunctions import tff, tarfileFromDirectory\n",
    "        if exists(directoryPath):\n",
    "            print(f'creating tarfilefrom: {directoryPath}\\n')\n",
    "            try: tff.tarfileFromDirectory(output_filename=fileName,\n",
    "                                          source_dir=directoryPath)\n",
    "            except BaseException as err: print(err)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2acec496",
   "metadata": {},
   "outputs": [],
   "source": [
    "def flipImage2(thisImage, axes):\n",
    "        '''hflp = flip(img, 0)\\nvflp = flip(img, 1)\\nbflp = flip(img,-1)'''\n",
    "        if (axes == 0): # horizental flip\n",
    "            return cv2.flip(thisImage, 0 )\n",
    "        elif(axes == 1): # vertical flip\n",
    "            return cv2.flip(thisImage, 1 )\n",
    "        elif(axes == -1): # both directions\n",
    "            return cv2.flip(thisImage, -1 )\n",
    "        \n",
    "\n",
    "def rotateImagesFixed2(path, silent=True, save=False):\n",
    "    '''Rotates images 90, 180, and 270 degrees fixed increments\\n'''\n",
    "    rotationList = ['90', '180', '270']\n",
    "    for angleString in rotationList:\n",
    "        newAngle=float(angleString)\n",
    "        appendFileName= 'rot' + angleString\n",
    "        originalImg = cvu.loadCV2Image(path)\n",
    "        # originalImg = cvu.resizeImage(originalImg)\n",
    "        rotImage = np.copy(originalImg)\n",
    "        rotImage = cvu.rotateImage(rotImage, newAngle)\n",
    "        savePath=''\n",
    "        if not silent:\n",
    "            savePath = cvu.getCV2SavePath(path,\n",
    "                                           append=appendFileName,\n",
    "                                           silent=False)\n",
    "            cvu.plotShowTwoImages(originalImg, rotImage,\n",
    "                                   title2=basename(savePath))\n",
    "            if save and not exists(savePath):\n",
    "                print(f'{C.ColorOff}saved to: {C.Green}{savePath}{C.ColorOff}\\n')\n",
    "                cvu.saveCV2Image(savePath, rotImage)\n",
    "            elif exists(savePath):\n",
    "                print(f'{C.ColorOff}file already exists : {C.IRed}{savePath}{C.ColorOff}\\n')\n",
    "# rotateImagesFixed2(enemyPath, silent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14bad36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import CV2_Utils\n",
    "from CV2_Utils import  *\n",
    "enemyPath = join(contentPath, 'enemy.png')\n",
    "# CV2_Utils.__dict__\n",
    "# dir(cvu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc8eade2",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(tfImagesPath)\n",
    "globList=[]\n",
    "globList=glob.glob('**', recursive=True)\n",
    "print(f'globList contains {len(globList)} files')\n",
    "\n",
    "for fil in sorted(globList):\n",
    "    fullPath=abspath(fil)\n",
    "    if fullPath.endswith('.png'):\n",
    "        # print(fullPath)\n",
    "        img = cvu.loadCV2Image(fullPath)\n",
    "        img = cvu.resizeImage(img)\n",
    "        savePath = cvu.getCV2SavePath(fullPath,silent=True)\n",
    "        if not exists(savePath):\n",
    "            cvu.saveCV2Image(savePath, img)\n",
    "            cvu.plotShowSingleImage(img, title1=basename(fullPath))\n",
    "            print(f'saved to: {C.Green}{savePath}{C.ColorOff}')\n",
    "        else:\n",
    "            print(f'already saved: {C.IRed}{savePath}{C.ColorOff}')\n",
    "        \n",
    "        sleep(0.1)\n",
    "        img=None\n",
    "sleep(1)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eb744cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "cv2GlobList=[]\n",
    "cv2GlobList=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(cv2GlobList)} files')\n",
    "\n",
    "scaleList=[0.25, 0.375, 0.5, 0.625, 0.75]\n",
    "for fil in sorted(cv2GlobList):\n",
    "    fullPath=abspath(fil)\n",
    "    if fullPath.endswith('.png'):\n",
    "        # print(fullPath)\n",
    "        for thisScale in scaleList:\n",
    "            # print(thisScale)\n",
    "            appendString = 'z' + str(thisScale)\n",
    "            appendString = appendString.replace('.', '')\n",
    "            # print(appendString)\n",
    "            savePath= cvu.getCV2SavePath(fullPath,\n",
    "                                         append=appendString)\n",
    "\n",
    "            if not exists(savePath):\n",
    "                img = cvu.loadCV2Image(fullPath)\n",
    "                zeroPixel = img[0, 0]\n",
    "                zoomImage = np.copy(img)\n",
    "                zoomImage = cvu.rotateImage(zoomImage,\n",
    "                                            newScale=thisScale)\n",
    "                sleep(0.1)\n",
    "                zoomImage = cvu.fillImage3(zoomImage, zeroPixel)\n",
    "                sleep(0.1)\n",
    "                cvu.plotShowTwoImages(img, zoomImage,\n",
    "                                     title1=basename(fullPath),\n",
    "                                     title2=basename(savePath))\n",
    "                sleep(0.1)\n",
    "                if not exists(savePath):\n",
    "                    cvu.saveCV2Image(savePath, zoomImage)\n",
    "                sleep(0.1)\n",
    "                img=None\n",
    "                zoomImage=None\n",
    "                print(f'saved to: {C.Green}{savePath}{C.ColorOff}')\n",
    "            else: print(f'saved to: {C.IRed}{savePath}{C.ColorOff}')\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8967a3b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "cv2GlobList=[]\n",
    "cv2GlobList=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(cv2GlobList)} files')\n",
    "\n",
    "for path in sorted(cv2GlobList):\n",
    "    fullPath=abspath(path)\n",
    "    if fullPath.endswith('.png') and fullPath.__contains__('z025'):\n",
    "        savePath=cvu.getCV2SavePath(fullPath, append='t-65')\n",
    "        img=cvu.loadCV2Image(fullPath)\n",
    "        zeroPixel=img[0,0]\n",
    "        trans = np.copy(img)\n",
    "        trans = cvu.translateImage(trans, x=-65, y=-65)\n",
    "        trans=cvu.fillImage3(trans, zeroPixel)\n",
    "        sleep(0.05)\n",
    "        cvu.plotShowTwoImages(trans, trans,\n",
    "                              title1=basename(fullPath),\n",
    "                              title2=basename(savePath))\n",
    "        if not exists(savePath):\n",
    "            cvu.saveCV2Image(savePath, trans)\n",
    "        print()\n",
    "        sleep(0.1)\n",
    "        img=None\n",
    "        trans=None\n",
    "        edges=None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d514a53f",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "cv2GlobList=[]\n",
    "cv2GlobList=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(cv2GlobList)} files')\n",
    "\n",
    "for pth in sorted(cv2GlobList):\n",
    "    fullPath=abspath(pth)\n",
    "    if fullPath.endswith('.png'):\n",
    "        rotateImagesFixed2(fullPath, silent=True, save=True)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fcb5e44",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "cv2GlobList=[]\n",
    "cv2GlobList=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(cv2GlobList)} files')\n",
    "\n",
    "for path in sorted(cv2GlobList):\n",
    "    fullPath=abspath(path)\n",
    "    savePath=cvu.getCV2SavePath(fullPath, append='hflp')\n",
    "    if fullPath.endswith('.png') and not exists(savePath):\n",
    "        # print(savePath)\n",
    "        img = cvu.loadCV2Image(fullPath)\n",
    "        copyImg = np.copy(img)\n",
    "        hflp = flipImage2(copyImg, axes=0)\n",
    "        cvu.plotShowTwoImages(copyImg, hflp,\n",
    "                             title1=basename(fullPath),\n",
    "                             title2=basename(savePath))\n",
    "        if not exists(savePath):\n",
    "            cvu.saveCV2Image(savePath, hflp)\n",
    "        sleep(0.1)\n",
    "        img=None\n",
    "        copyImg=None\n",
    "        hflp=None\n",
    "        \n",
    "    savePath=cvu.getCV2SavePath(fullPath, append='vflp')\n",
    "    if fullPath.endswith('.png') and not exists(savePath):\n",
    "        # print(savePath)\n",
    "        img = cvu.loadCV2Image(fullPath)\n",
    "        copyImg = np.copy(img)\n",
    "        vflp = flipImage2(copyImg, axes=1)\n",
    "        cvu.plotShowTwoImages(copyImg, vflp,\n",
    "                             title1=basename(fullPath),\n",
    "                             title2=basename(savePath))\n",
    "        if not exists(savePath):\n",
    "            cvu.saveCV2Image(savePath, vflp)\n",
    "            sleep(0.1)\n",
    "            img=None\n",
    "            copyImg=None\n",
    "            vflp=None\n",
    "\n",
    "    savePath=cvu.getCV2SavePath(fullPath, append='bflp')\n",
    "    if fullPath.endswith('.png') and not exists(savePath):\n",
    "        # print(savePath)\n",
    "        img = cvu.loadCV2Image(fullPath)\n",
    "        copyImg = np.copy(img)\n",
    "        bflp = flipImage2(copyImg, axes=-1)\n",
    "        cvu.plotShowTwoImages(copyImg, bflp,\n",
    "                             title1=basename(fullPath),\n",
    "                             title2=basename(savePath))\n",
    "        sleep(0.1)\n",
    "        if not exists(savePath):\n",
    "            cvu.saveCV2Image(savePath, bflp)\n",
    "            sleep(0.05)\n",
    "        sleep(0.1)\n",
    "        img=None\n",
    "        copyImg=None\n",
    "        bflp=None\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0468a14",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(cv2Path)\n",
    "cv2GlobList=[]\n",
    "cv2GlobList=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(cv2GlobList)} files')\n",
    "\n",
    "for path in sorted(cv2GlobList):\n",
    "    fullPath=abspath(path)\n",
    "    if fullPath.endswith('.png'):\n",
    "        img_name=basename(fullPath)\n",
    "        name = img_name\n",
    "        img=cvu.loadCV2Image(fullPath)\n",
    "        sleep(0.05)\n",
    "        copy=np.copy(img)\n",
    "        imgEdges=cvu.edgeDetection(copy)\n",
    "        sleep(0.05)\n",
    "        cvu.plotShowTwoImages(img, imgEdges,\n",
    "                              title1=img_name, title2=name)\n",
    "        sleep(0.05)\n",
    "        img=None\n",
    "        copy=None\n",
    "        imgEdges=None\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9771c84f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "os.chdir(cv2Path)\n",
    "imageGlob=[]\n",
    "imageGlob=glob.glob('**', recursive=True)\n",
    "print(f'cv2GlobList contains {len(imageGlob)} files')\n",
    "\n",
    "def plotShowManyImages(image_list):\n",
    "    ''' under construction '''\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    for images, labels in image_list.take(2):\n",
    "        for i in range(9):\n",
    "            ax = plt.subplot(3, 3, i + 1)\n",
    "            plt.imshow(images[i].numpy().astype(\"uint8\"))\n",
    "            plt.title(class_names[labels[i]])\n",
    "            plt.axis(\"off\")\n",
    "# plotShowManyImages(imageGlob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74b25a91",
   "metadata": {},
   "outputs": [],
   "source": [
    "from TarfileFunctions import *\n",
    "# tff.tarfileFromDirectory('All_CV2_Images.tar.gz', cv2Path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fe2358c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "CV2_Utils_Module.ipynb",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}