CV2_Utilities.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "colab": {
      "name": "CV2_Utilities.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/iypc-team/CoLab/blob/master/CV2_Utilities.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "substantial-responsibility"
      },
      "source": [
        "# 08/24/2021-1\n",
        "from __future__ import absolute_import\n",
        "from IPython.display import clear_output, display\n",
        "import glob, os, shutil, sys, uuid\n",
        "from os.path import *\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",
        "import numpy as np\n",
        "\n",
        "if exists('/content/sample_data'):\n",
        "    shutil.rmtree('/content/sample_data')\n",
        "\n",
        "contentPth = os.getcwd()\n",
        "tensorflowImagesPath = join(contentPth, 'TensorflowImages')\n",
        "resizedImagesPath = join(contentPth, '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",
        "    from TarfileFunctions import *\n",
        "    from BashColors import C\n",
        "    \n",
        "    if not exists(tensorflowImagesPath):\n",
        "        shutil.copytree(gdriveTFImagesPth, tensorflowImagesPath)\n",
        "        # tff.listTarfiles()\n",
        "        os.chdir(contentPth)\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(contentPth)\n",
        "\n",
        "except Exception as err:\n",
        "    # print(err)\n",
        "    os.chdir(contentPth)\n",
        "    from TarfileFunctions import *\n",
        "    from BashColors import C\n",
        "    tarfilePath=join(contentPth, 'Juno_Original_Images.tar.gz')\n",
        "    if exists(tarfilePath) and not exists(tensorflowImagesPath):\n",
        "        tff.extractTarfiles('Juno_Original_Images.tar.gz')\n",
        "\n",
        "rootPth = expanduser(\"~\")\n",
        "\n",
        "resizedImagesPath = join(contentPth, 'TensorflowResizedImages')\n",
        "print(tensorflowImagesPath)\n",
        "os.chdir(tensorflowImagesPath)\n",
        "tfImageGlob = glob.glob('**', recursive=True)\n",
        "\n",
        "os.chdir(contentPth)\n",
        "cv2ImagesPath = join(contentPth, 'CV2Images')\n",
        "cv2EnemyPath = join(cv2ImagesPath, 'Enemy')\n",
        "cv2FriendlyPath = join(cv2ImagesPath, 'Friendly')\n",
        "if not exists(cv2ImagesPath):\n",
        "    os.mkdir(cv2ImagesPath)\n",
        "    os.mkdir(cv2EnemyPath)\n",
        "    os.mkdir(cv2FriendlyPath)\n",
        "\n",
        "print(f'cv2: {C.IBlue}{cv2.__version__}{C.ColorOff}')\n",
        "print(f'cwd: {C.IBlue}{os.getcwd()}')\n",
        "\n",
        "# os.chdir(mydrivePth)\n"
      ],
      "id": "substantial-responsibility",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dtSs4lFVOuii"
      },
      "source": [
        "%%writefile CV2_Utils.py\n",
        "\n",
        "class CV2_Utils(object):\n",
        "    ''' '''\n",
        "    import glob, os, shutil, sys, uuid\n",
        "    import cv2\n",
        "    import numpy as np\n",
        "    from matplotlib import pyplot as plt\n",
        "\n",
        "    def __init__(self, cvu, zeroPixel):\n",
        "        self.cvu = CV2_Utils\n",
        "        self.zeroPixel = np.ndarray([0, 0, 0, 0])\n",
        "        print(self.zeroPixel)\n",
        "\n",
        "cvu = CV2_Utils()"
      ],
      "id": "dtSs4lFVOuii",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sHKUixeox6rM"
      },
      "source": [
        "print(os.getcwd())\n",
        "import CV2_Utils\n",
        "from CV2_Utils import *\n",
        "print(cvu.zeroPixel)\n",
        "help(cvu)\n",
        "q"
      ],
      "id": "sHKUixeox6rM",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sophisticated-magazine"
      },
      "source": [
        "zeroPixel:np.ndarray\n",
        "originalImageZeroPixel:np.ndarray\n",
        "\n",
        "def cv2ShowTwoImages(img1, img2):\n",
        "    ''' '''\n",
        "    img1 = cv2ResizeImage(img1)\n",
        "    img2 = cv2ResizeImage(img2)\n",
        "    combinedImage = cv2.hconcat([img1, img2])\n",
        "    try:\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "        cv2_imshow(combinedImage)\n",
        "    except: matPlotCompareTwoImages(img1, img2)\n",
        "\n",
        "def matPlotShowSingleImage(thisImage):\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",
        "    ax1.axis('off')\n",
        "\n",
        "def matPlotCompareTwoImages(thisImage, compareImage):\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",
        "    ax1.axis('off')\n",
        "    # ax1.set_title('Original Image')\n",
        "\n",
        "    ax2 = fig.add_subplot(1,2,2)\n",
        "    ax2.imshow(compareImage)\n",
        "    ax2.axis('off')\n",
        "    # ax2.set_title('New Image')\n",
        "    plt.show()\n",
        "\n",
        "def cv2ResizeImage(thisImage, newSize=(224,224)):\n",
        "    '''return resized_image'''\n",
        "    resized_image = cv2.resize(thisImage,newSize,interpolation=cv2.INTER_CUBIC)\n",
        "    return resized_image\n",
        "\n",
        "def cv2CreateImageWithColor(pxColor, silent=True):\n",
        "    '''return save_path'''\n",
        "    bgImagePath = join(contentPth, 'TensorflowImages/backgroundImage224.png')\n",
        "    bgImage = cv2.imread(bgImagePath, cv2.IMREAD_UNCHANGED)\n",
        "    save_path = join(contentPth, 'bgImage.png')\n",
        "    # print(save_path)\n",
        "    bgImage = np.copy(bgImage)\n",
        "    # print(bgImage[0][0])\n",
        "\n",
        "    for px in bgImage:\n",
        "        bgImage[:] = pxColor\n",
        "        cv2.waitKey(100)\n",
        "        \n",
        "    cv2.imwrite(save_path, bgImage)\n",
        "    if not silent:\n",
        "        print(f'shape: {bgImage.shape}')\n",
        "        # cv2_imshow(bgImage)\n",
        "        matPlotCompareTwoImages(bgImage, bgImage)\n",
        "    return save_path\n",
        "\n",
        "def cv2ZoomImage(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 = cv2FillImage(zoomImage)\n",
        "    if not silent:\n",
        "        print('cv2ZoomImage()')\n",
        "        matPlotCompareTwoImages(thisImage, zoomImage)\n",
        "    return zoomImage\n",
        "\n",
        "def cv2Rotation(thisImage, angle=0, rotPoint=None, newScale=1, silent=True):\n",
        "    '''return rotImage'''\n",
        "    thisImage = np.copy(thisImage)\n",
        "    zeroPixel = thisImage[[0][0]]\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",
        "            matPlotCompareTwoImages(thisImage, rotImage)\n",
        "            cv2.waitKey(100)\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "        return rotImage\n",
        "\n",
        "def cv2Translate(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",
        "        matPlotCompareTwoImages(thisImage, newImage)\n",
        "\n",
        "    try:\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "    except: pass\n",
        "    return newImage\n",
        "\n",
        "def cv2EdgeDetection(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",
        "        matPlotCompareTwoImages(thisImage, canny)\n",
        "    try:\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "    except: pass\n",
        "    return canny\n",
        "\n",
        "def changeBackgroundColors(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(contentPth, fileName)\n",
        "\n",
        "    print(f'saveImagePath: {saveImagePath}')\n",
        "    original_image = cv2.imread(path, cv2.IMREAD_UNCHANGED)\n",
        "    originalZeroPixel = originalImage[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(100)\n",
        "        cv2.destroyAllWindows()\n",
        "    except: pass\n",
        "    return newImg\n",
        "\n",
        "def cv2FillImage(thisImage, silent=True):\n",
        "    '''returns filledImage'''\n",
        "    print('cv2FillImage')\n",
        "    # matPlotShowSingleImage(thisImage)\n",
        "    zp = thisImage[0][0]\n",
        "    bgImagePath = cv2CreateImageWithColor(pxColor=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",
        "        cv2ShowTwoImages(img1, filledImage)\n",
        "    try:\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "    except: pass\n",
        "    return filledImage\n",
        "\n",
        "\n",
        "def cv2AddTwoImages(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 cv2FlipImage(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('flip vertical')\n",
        "            cv2ShowTwoImages(thisImage, flipImg)\n",
        "    elif axes == 1:\n",
        "        flipImg = cv2.flip(thisImage, 1)\n",
        "        if not silent:\n",
        "            print('flip horizontal')\n",
        "            cv2ShowTwoImages(thisImage,flipImg)\n",
        "    elif axes == -1:\n",
        "        flipImg =cv2.flip(thisImage, -1)\n",
        "        if not silent:\n",
        "            print('flip vertical and horizontal')\n",
        "            cv2ShowTwoImages(thisImage,flipImg)\n",
        "    cv2.waitKey(100)\n",
        "    cv2.destroyAllWindows()\n",
        "    return flipImg\n",
        "\n",
        "def cv2GetUniqueFileName(extension='.png'):\n",
        "    '''return uniqueName'''\n",
        "    uniqueName = str(uuid.uuid4()) + extension\n",
        "    return uniqueName\n",
        "\n",
        "def cv2SaveImage(savePath, thisImage, writeFile=False):\n",
        "    ''' '''\n",
        "    if savePath.__contains__('Enemy') or savePath.__contains__('enemy'):\n",
        "        print('Enemy')\n",
        "        print(savePath)\n",
        "        dirPath, fileName = split(savePath)\n",
        "        print(dirPath, fileName)\n",
        "        newPath = join(cv2EnemyPath, fileName)\n",
        "        if writeFile:\n",
        "            cv2.imwrite(newPath, thisImage)\n",
        "\n",
        "    elif savePath.__contains__('Friendly') or savePath.__contains__('friendly'):\n",
        "        print('Friendly')\n",
        "        print(savePath)\n",
        "        dirPath, fileName = split(savePath)\n",
        "        print(dirPath, fileName)\n",
        "        newPath = join(cv2FriendlyPath, fileName)\n",
        "        if writeFile:\n",
        "            cv2.imwrite(newPath, thisImage)\n",
        "\n",
        "    else: \n",
        "        print('Path must include either enemy or friendly')\n",
        "        print(savePath)\n",
        "        # cv2.imwrite(savePath, thisImage)"
      ],
      "id": "sophisticated-magazine",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sustained-joining"
      },
      "source": [
        ""
      ],
      "id": "sustained-joining",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DmKJCtFp3pv5"
      },
      "source": [
        "tfImagePathList=[]\n",
        "tfImageGlob = sorted(tfImageGlob)\n",
        "for filPth in tfImageGlob:\n",
        "    fullPath = abspath(filPth)\n",
        "    if fullPath.endswith('.png'):\n",
        "        dirName = dirname(filPth)\n",
        "        fileName = basename(filPth)\n",
        "        imagePath = join(tensorflowImagesPath, dirName)\n",
        "        imagePath = join(imagePath, fileName)\n",
        "        print('imagePath:', imagePath)\n",
        "        \n",
        "        savePath = join(contentPth, fileName)\n",
        "        print('savePath:', savePath)\n",
        "\n",
        "        cv2.waitKey(50)\n",
        "        img = cv2.imread(imagePath, cv2.IMREAD_UNCHANGED)\n",
        "        img = cv2ResizeImage(img)\n",
        "        cv2_imshow(img)\n",
        "        cv2SaveImage(savePath, img)\n",
        "        if fileName != 'backgroundImage224.png':\n",
        "            tfImagePathList.append(savePath)\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "        print()\n",
        "\n",
        "clear_output()"
      ],
      "id": "DmKJCtFp3pv5",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XfTHb4AR-iVe"
      },
      "source": [
        "print('tfImagePathList:', len(tfImagePathList), 'files')\n",
        "for path in sorted(tfImagePathList):\n",
        "    if exists(path):\n",
        "        print(path)\n",
        "        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)\n",
        "        img = cv2ResizeImage(img)\n",
        "        cv2_imshow(img)\n",
        "        cv2SaveImage(savePath=path, thisImage=img)\n",
        "        cv2.waitKey(100)\n",
        "        cv2.destroyAllWindows()\n",
        "        print()\n"
      ],
      "id": "XfTHb4AR-iVe",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_uC6Fwf2-XRc"
      },
      "source": [
        "\n",
        "pth = join(tensorflowImagesPath, 'Enemy')\n",
        "pth = join(pth, 'enemy_1.png')\n",
        "shutil.copy2(pth, contentPth)\n",
        "enemyPath = join(contentPth, 'enemy_1.png')\n",
        "\n",
        "originalImage = cv2.imread(enemyPath, cv2.IMREAD_UNCHANGED)\n",
        "originalImage = cv2ResizeImage(originalImage)\n",
        "enemyImg = np.copy(originalImage)\n",
        "zeroPixel = enemyImg[0][0]\n",
        "print(zeroPixel)\n",
        "\n",
        "try:\n",
        "    cv2.waitKey(100)\n",
        "    cv2.destroyAllWindows()\n",
        "except: pass"
      ],
      "id": "_uC6Fwf2-XRc",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ry4-VpV7AJz7"
      },
      "source": [
        "img = cv2ZoomImage(enemyImg, newScale=0.5, silent=False)"
      ],
      "id": "Ry4-VpV7AJz7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0uoUFS1eTy4m"
      },
      "source": [
        "rotImg = cv2Rotation(enemyImg, 90, newScale=.5)\n",
        "\n",
        "cv2_imshow(rotImg)\n",
        "print()\n",
        "_=cv2EdgeDetection(rotImg, silent=False)"
      ],
      "id": "0uoUFS1eTy4m",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOsc9zkLVcTk"
      },
      "source": [
        "enemyOriginal = np.copy(originalImage)\n",
        "# enemyOriginal = cv2ResizeImage(enemyOriginal)\n",
        "enemyOriginal = cv2ZoomImage(enemyOriginal)\n",
        "canny = cv2EdgeDetection(enemyOriginal)\n",
        "cv2_imshow(enemyOriginal)\n",
        "cv2_imshow(canny)"
      ],
      "id": "QOsc9zkLVcTk",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WHJzvEzJ17--"
      },
      "source": [
        "cvImagePathList=[]\n",
        "os.chdir(cv2ImagesPath)\n",
        "cvGlob = glob.glob('**', recursive=True)\n",
        "for pth in sorted(cvGlob):\n",
        "    if pth.endswith('.png'):\n",
        "        print(f'path: {pth}')\n",
        "        fullPath = abspath(pth)\n",
        "        print(f'fullPath: {C.Green}{fullPath}{C.ColorOff}\\n')\n",
        "        cvImagePathList.append(fullPath)\n",
        "clear_output()\n",
        "print(f'cvImagePathList: {len(cvImagePathList)} files')"
      ],
      "id": "WHJzvEzJ17--",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4wzP9G5nAMG9"
      },
      "source": [
        "\n",
        "for path in sorted(cvImagePathList):\n",
        "    if exists(path) and path.endswith('.png'):\n",
        "        print(path)\n",
        "        # dirName, _ = split(path)\n",
        "        # fileName = cv2GetUniqueFileName()\n",
        "        # print('dirName:', dirName)\n",
        "        # print('fileName:', fileName)\n",
        "        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)\n",
        "        # img = cv2ResizeImage(img)\n",
        "        cv2_imshow(img)\n",
        "        print(img.shape)\n",
        "        print()\n",
        "        flipImage = cv2FlipImage(img, axes=0,silent=False)\n",
        "        # img = cv2EdgeDetection(img, silent=False)\n",
        "        savePath = join(contentPth, cv2GetUniqueFileName(extension='_flip.png'))\n",
        "        print(savePath)\n",
        "\n",
        "        flipImage = cv2FlipImage(img, axes=1, silent=False)\n",
        "        #img = cv2EdgeDetection(img, silent=False)\n",
        "\n",
        "        flipImage = cv2FlipImage(img, axes=-1, silent=False)\n",
        "        # edges = cv2EdgeDetection(img, silent=False)\n"
      ],
      "id": "4wzP9G5nAMG9",
      "execution_count": null,
      "outputs": []
    }
  ]
}