1_tiling_and_augmentation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/colurw/data_augmentation/blob/master/PascalVOC_Tiling_and_Augmentation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kgdJHL1mpvEv"
      },
      "source": [
        "## Split JPGs into numbered tiles\n",
        "In order to reduce RAM allocation during training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "3lvd2Mi2pt9D"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2\n",
        "import math\n",
        "\n",
        "TILE_SIZE = (2240, 2240)   # (x,y)\n",
        "OFFSET = (2240, 2240)      # (x,y)\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition/Mask_RCNN/skin data'\n",
        "\n",
        "# create folder to receive output\n",
        "os.chdir(PATH)\n",
        "if not os.PATH.exists('tiled output'):\n",
        "    os.mkdir('tiled output')\n",
        "\n",
        "# iterate through training photos\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.JPG'): \n",
        "        continue\n",
        "\n",
        "    # check dimensions\n",
        "    img = cv2.imread(str(PATH)+'/'+str(filename))  \n",
        "    img_shape = img.shape                           # all photos are 4480 x 6720 (y,x)!\n",
        "\n",
        "    # split each photo into six (3x2) tiles\n",
        "    for i in range(int(math.ceil(img_shape[0] / (OFFSET[1] * 1.0)))):\n",
        "        for j in range(int(math.ceil(img_shape[1] / (OFFSET[0] * 1.0)))):\n",
        "            cropped_img = img[OFFSET[1] * i : min(OFFSET[1] * i+TILE_SIZE[1], img_shape[0]), \\\n",
        "                          OFFSET[0]*j : min(OFFSET[0] * j+TILE_SIZE[0], img_shape[1])]\n",
        "            x_min = OFFSET[0] * j\n",
        "            y_min = OFFSET[1] * i\n",
        "            x_max = min(OFFSET[0] * j + TILE_SIZE[0], img_shape[1])\n",
        "            y_max = min(OFFSET[1] * i + TILE_SIZE[1], img_shape[0])\n",
        "            print('relative coordinates: (', '%4.f' % x_min, ', %4.f' % y_min, ')   filename: '  + str(filename[:-4]) + '__' + str(i) + '_' + str(j) + '.JPG')\n",
        "            \n",
        "            # save image tiles to output folder using original filename and tile reference\n",
        "            cv2.imwrite(str(PATH) + '/tiled output/' + str(filename[:-4]) + '__' + str(i) + '_' + str(j) + '.JPG', cropped_img)\n",
        "            "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "LPaTx8uPo99t"
      },
      "source": [
        "# Split XML label files into numbered tiles\n",
        "To match tiled images.  Appends object count in each class to the filename for easy sorting later"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "QqP0bwvZTHpo"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import xml.etree.ElementTree as ET\n",
        "import math\n",
        "\n",
        "IMG_SHAPE = (4480, 6720)    # (y,x)!   \n",
        "TILE_SIZE = (2240, 2240)    # (x,y)\n",
        "OFFSET = (2240, 2240)       # (x,y)\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition/Mask_RCNN/skin data'\n",
        "\n",
        "# create folder to receive output\n",
        "os.chdir(PATH)\n",
        "if not os.path.exists('tiled output'):\n",
        "    os.mkdir('tiled output')\n",
        "\n",
        "# iterate through xml files\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.xml'): \n",
        "        continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "\n",
        "    # iterate through tile boundaries\n",
        "    for i in range(int(math.ceil(IMG_SHAPE[0] / (OFFSET[1] * 1.0)))):\n",
        "        for j in range(int(math.ceil(IMG_SHAPE[1] / (OFFSET[0] * 1.0)))):\n",
        "            X_MIN = OFFSET[0]*j\n",
        "            Y_MIN = OFFSET[1]*i\n",
        "            X_MAX = min(OFFSET[0]*j+TILE_SIZE[0], IMG_SHAPE[1])\n",
        "            Y_MAX = min(OFFSET[1]*i+TILE_SIZE[1], IMG_SHAPE[0])\n",
        "            print('tile relative coordinates: (', '%4.f' % X_MIN, ', %4.f' % Y_MIN, ')   filename: ' + str(filename[:-4]) + \"_\" + str(i) + '_' + str(j) + '_...' )\n",
        "\n",
        "            # reload parent xml file\n",
        "            tree = ET.parse(fullname)\n",
        "            root = tree.getroot()\n",
        "\n",
        "            # remove objects outside current tile boundary\n",
        "            for object in root.findall('object'):\n",
        "                bndbox = object.find('bndbox')\n",
        "                Xmin_ = bndbox.find('xmin')\n",
        "                Xmax_ = bndbox.find('xmax')\n",
        "                Ymin_ = bndbox.find('ymin')\n",
        "                Ymax_ = bndbox.find('ymax')\n",
        "                if int(Xmin_.text) < X_MIN or \\\n",
        "                int(Xmax_.text) > X_MAX or \\\n",
        "                int(Ymin_.text) < Y_MIN or \\\n",
        "                int(Ymax_.text) > Y_MAX: \n",
        "                    root.remove(object)\n",
        "\n",
        "            # count remaining objects\n",
        "            count_fb = 0\n",
        "            for any in root.findall(\"./object/[name='follicular_bump']\"):\n",
        "                count_fb = count_fb + 1\n",
        "            \n",
        "            count_pe = 0\n",
        "            for any in root.findall(\"./object/[name='pre_erupted']\"):\n",
        "                count_pe = count_pe + 1\n",
        "\n",
        "            # update linked JPG reference\n",
        "            _filename = root.find('filename')\n",
        "            newfn = str(_filename.text[:-4] + \"__\" + str(i) + \"_\" + str(j) + \".JPG\")\n",
        "            _filename.text = str(newfn)\n",
        "            \n",
        "            _PATH = root.find('PATH')\n",
        "            newpa = str(_PATH.text[:-4] + \"__\" + str(i) + \"_\" + str(j) + \".JPG\")\n",
        "            _PATH.text = str(newpa)\n",
        "\n",
        "            # update width & height references\n",
        "            size = root.find('size')\n",
        "            _width = size.find('width')\n",
        "            _width.text = str(TILE_SIZE[0])\n",
        "            _height = size.find('height')\n",
        "            _height.text = str(TILE_SIZE[1])\n",
        "\n",
        "            # subtract tile relative coordinates from each feature's bounding box\n",
        "            for _xmin in root.iter('xmin'):\n",
        "                new_xmin = int(_xmin.text) - X_MIN\n",
        "                _xmin.text = str(new_xmin)\n",
        "                #xmin.set('updated', 'yes')\n",
        "\n",
        "            for _ymin in root.iter('ymin'):\n",
        "                new_ymin = int(_ymin.text) - Y_MIN\n",
        "                _ymin.text = str(new_ymin)\n",
        "                #xmin.set('updated', 'yes')\n",
        "\n",
        "            for _xmax in root.iter('xmax'):\n",
        "                new_xmax = int(_xmax.text) - X_MIN\n",
        "                _xmax.text = str(new_xmax)\n",
        "                #xmin.set('updated', 'yes')\n",
        "\n",
        "            for _ymax in root.iter('ymax'):\n",
        "                new_ymax = int(_ymax.text) - Y_MIN\n",
        "                _ymax.text = str(new_ymax)\n",
        "                #xmin.set('updated', 'yes')\n",
        "\n",
        "            # save xml tiles to output folder using original filename and tile reference\n",
        "            tree.write(str(PATH)+\"/tiled output/\"+str(filename[:-4])+\"__\"+str(i)+\"_\"+str(j)+\"__\"+str(count_fb).zfill(2)+\"_\"+str(count_pe).zfill(2)+\".xml\")\n",
        "            "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "vTGQ7h2O2ciz"
      },
      "source": [
        "# Remove JPG / XML tiles without objects\n",
        "Based on tags in the XML file name\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "U4UyKL6VaPkz"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition/Mask_RCNN/skin data'\n",
        "SOURCE = 'tiled output'\n",
        "\n",
        "# create file to receive output\n",
        "os.chdir(PATH)\n",
        "if not os.path.exists('unlabelled output'):\n",
        "    os.mkdir('unlabelled output')\n",
        "\n",
        "# iterate through xml files\n",
        "for file in os.listdir(SOURCE):\n",
        "    if file.endswith('.xml'):\n",
        "        obj_tags = file[-9:-4]\n",
        "        img_name = str(file[:-11]+'.JPG')\n",
        "\n",
        "        # if xml file contains no objects, send xml file and matching jpg to output folder \n",
        "        if obj_tags == str('00_00'):\n",
        "            print(file)\n",
        "            shutil.move(os.path.join(SOURCE, file), 'unlabelled output')\n",
        "            shutil.move(os.path.join(SOURCE, img_name), 'unlabelled output')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KnQwfSeQ2mZg"
      },
      "source": [
        "# Mirror JPGs on YY axis\n",
        "To double the training data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "vdgDLK2w9P7C"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# iterate through image tiles\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.JPG'): \n",
        "        continue\n",
        "    \n",
        "    # flip and save with YY prefix\n",
        "    img = cv2.imread(PATH+'/'+filename)\n",
        "    img_flip_lr = cv2.flip(img, 1)\n",
        "    cv2.imwrite(PATH +'/YY_'+str(filename), img_flip_lr)\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "p7Xnzqwi3s4y"
      },
      "source": [
        "# Mirror XML label files on YY axis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "jXqQ3hgTg05w"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import xml.etree.ElementTree as ET\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# iterate through xml files in folder\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.xml'): continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "    tree = ET.parse(fullname)\n",
        "    root = tree.getroot()\n",
        "\n",
        "    # add YY prefix to linked jpg reference\n",
        "    filename_ = root.find('filename')\n",
        "    newfn = 'YY_'+str(filename_.text)\n",
        "    filename_.text = str(newfn)\n",
        "    print(str(newfn))\n",
        "\n",
        "    # add YY prefix to linked jpg path\n",
        "    path_ = root.find('path')\n",
        "    newpath = path_.text[:74] +str(newfn)+'.xml'\n",
        "    path_.text = str(newpath)\n",
        "\n",
        "    # get image width\n",
        "    imagewidth = int(root[4][0].text)\n",
        "    print('width:',imagewidth)\n",
        "\n",
        "    # iterate through all object bounding boxes\n",
        "    for object in root.findall('object'):\n",
        "        bndbox = object.find('bndbox')\n",
        "        Xmin_ = bndbox.find('xmin')\n",
        "        Xmax_ = bndbox.find('xmax')\n",
        "        \n",
        "        # rewrite bounding box coordinates to apply YY flip\n",
        "        Xmin_1 = imagewidth-int(Xmax_.text)\n",
        "        Xmax_1 = imagewidth-int(Xmin_.text)\n",
        "        print(Xmin_.text, Xmax_.text,' >>> ', Xmin_1, Xmax_1)\n",
        "        Xmin_.text = str(Xmin_1)\n",
        "        Xmax_.text = str(Xmax_1)\n",
        "\n",
        "    # save xml file with YY prefix\n",
        "    tree.write(PATH+'/YY_'+str(filename))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "osvDIo7LJhWj"
      },
      "source": [
        "# Mirror JPGs on XX axis\n",
        "To quadruple the training data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "aVWwha6TJJ5V"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# iterate through image tiles\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.JPG'): continue\n",
        "    \n",
        "    # flip and save with XX prefix\n",
        "    img = cv2.imread(PATH +'/'+ filename)\n",
        "    img_flip_ud = cv2.flip(img, 0)\n",
        "    cv2.imwrite(PATH +'/XX_'+str(filename), img_flip_ud)\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "0bEbHrj84u-B"
      },
      "source": [
        "# Mirror XML label files on XX axis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "UDDvev_Y76Ef"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import xml.etree.ElementTree as ET\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# iterate through xml files in folder\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.xml'): continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "    tree = ET.parse(fullname)\n",
        "    root = tree.getroot()\n",
        "\n",
        "    # add XX prefix to linked jpg reference\n",
        "    filename_ = root.find('filename')\n",
        "    newfn = 'XX_'+str(filename_.text)\n",
        "    filename_.text = str(newfn)\n",
        "    print(str(newfn))\n",
        "\n",
        "    # add YY prefix to linked jpg path\n",
        "    path_ = root.find('path')\n",
        "    newpath = path_.text[:-12] +str(newfn)+'.xml'\n",
        "    path_.text = str(newpath)\n",
        "\n",
        "    # get image height\n",
        "    imageheight = int(root[4][1].text)\n",
        "    print('height:',imageheight)\n",
        "\n",
        "    # iterate through all object bounding boxes\n",
        "    for object in root.findall('object'):\n",
        "        bndbox = object.find('bndbox')\n",
        "        Ymin_ = bndbox.find('ymin')\n",
        "        Ymax_ = bndbox.find('ymax')\n",
        "\n",
        "        # rewrite bounding box coordinates to apply XX flip\n",
        "        Ymin_1 = imageheight-int(Ymax_.text)\n",
        "        Ymax_1 = imageheight-int(Ymin_.text)\n",
        "        print(Ymin_.text, Ymax_.text,' >>> ', Ymin_1, Ymax_1)\n",
        "        Ymin_.text = str(Ymin_1)\n",
        "        Ymax_.text = str(Ymax_1)\n",
        "\n",
        "    # save xml file with XX prefix\n",
        "    tree.write(PATH+'/XX_'+str(filename))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CYkkU4X0VKYW"
      },
      "source": [
        "# Remove object tags from XML filenames"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "9bgsG6FAIDJh"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "path = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "for oldname in os.listdir(path):\n",
        "    if oldname.endswith('.xml'):\n",
        "        newname = oldname[:-11] + '.xml'\n",
        "        os.rename(os.path.join(path, oldname), os.path.join(path, newname))\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "YFsDdtjN7tMJ"
      },
      "source": [
        "# Set aside some JPG / XML pairs for test dataset "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "-zuIsZx64BwR"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "from random import seed\n",
        "from random import randint\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition/Mask_RCNN/skin data'\n",
        "SOURCE = 'tiled output'\n",
        "\n",
        "# count file pairs in folder\n",
        "file_num = 0\n",
        "os.chdir(PATH)\n",
        "for filename in os.listdir(SOURCE):\n",
        "    if filename.endswith('.xml'):\n",
        "        file_num +=1\n",
        "\n",
        "# choose how many to set aside\n",
        "print('Number of labelled image files in folder:', file_num)\n",
        "print('How many to move to validation dataset ?')\n",
        "files_to_set_aside = input()\n",
        "\n",
        "# create folder to receive selected files\n",
        "if not os.PATH.exists('validation set'):\n",
        "    os.mkdir('validation set')\n",
        "\n",
        "# iterate through xml files and select at random\n",
        "count = 0\n",
        "while count < int(files_to_set_aside):\n",
        "    for filename in os.listdir(SOURCE):\n",
        "        if filename.endswith('.xml'):\n",
        "            img_name = str(filename[:-11]+'.JPG')\n",
        "            rand_num = randint(0, 50)\n",
        "            if rand_num == 50:\n",
        "                print(img_name)\n",
        "                print(filename,'\\n')\n",
        "                count +=  1\n",
        "\n",
        "                # move chosen xml/jpg file pair to new folder\n",
        "                shutil.move(os.PATH.join(SOURCE, filename), 'validation set')\n",
        "                shutil.move(os.PATH.join(SOURCE, img_name), 'validation set')\n",
        "                "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "G6xLf_UnDO3Z"
      },
      "source": [
        "# Rotate JPGs clockwise\n",
        "Doubles traing data for each ANGLE entered."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "7Y-PrqVQzOwE"
      },
      "outputs": [],
      "source": [
        "from PIL import Image\n",
        "import os\n",
        "\n",
        "ANGLE = 10   # must be positive \n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# create folder to receive files\n",
        "os.chdir(PATH)\n",
        "if not os.PATH.exists('rotated'):\n",
        "    os.mkdir('rotated')\n",
        "\n",
        "# iterate through images\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.JPG'): continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "    image = Image.open(fullname)\n",
        "\n",
        "    # rotate image\n",
        "    output = image.rotate(-ANGLE, resample=3, expand=False)\n",
        "    print(image.size, '>>>', output.size)\n",
        "\n",
        "    # save image with CW_ANGLE prefixed to filename \n",
        "    output.save(PATH+'/rotated/CW'+str(ANGLE)+'__'+str(filename))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jEm5hhlJ9JuG"
      },
      "source": [
        "# Rotate XML label files clockwise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "KGW0R7VT8Ueb"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import xml.etree.ElementTree as ET\n",
        "import math\n",
        "\n",
        "ANGLE = 10                # must be positive \n",
        "EXPANDED_PHOTO = False    # should match expand= arg in image.rotate() in previous cell\n",
        "CIRCULAR_OBJECTS = True   # bounding boxes will expand when set to False\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# create folder to receive files\n",
        "os.chdir(PATH)\n",
        "if not os.path.exists('rotated'):\n",
        "    os.mkdir('rotated')\n",
        "\n",
        "# iterate through xml files\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.xml'): continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "    tree = ET.parse(fullname)\n",
        "    root = tree.getroot()\n",
        "\n",
        "    # update filename reference\n",
        "    filename_ = root.find('filename')\n",
        "    newfn = 'CW'+str(ANGLE)+'__'+str(filename_.text)\n",
        "    filename_.text = str(newfn)\n",
        "    print(str(newfn))\n",
        "\n",
        "    # calculate centre of rotation\n",
        "    imagewidth = int(root[4][0].text)\n",
        "    imageheight = int(root[4][1].text)\n",
        "    rotation_centre = imagewidth/2, imageheight/2\n",
        "    theta = ANGLE * 3.14159 / 180\n",
        "    \n",
        "    # calculate size of expanded image\n",
        "    if EXPANDED_PHOTO == True:\n",
        "        expanded_image_dims = math.ceil(math.cos(theta) * imagewidth + math.sin(theta) * imageheight), \\\n",
        "                              math.ceil(math.sin(theta) * imagewidth + math.cos(theta) * imageheight)\n",
        "        \n",
        "        # expand bounding box to avoid clipping rotated objects\n",
        "        if CIRCULAR_OBJECTS == True:\n",
        "            expansion_factor = 1\n",
        "        else:\n",
        "            expansion_factor = math.ceil(expanded_image_dims[0] / imagewidth)\n",
        "        \n",
        "        # update width & height references\n",
        "        size = root.find('size')\n",
        "        _width = size.find('width')\n",
        "        _width.text = str(expanded_image_dims[0])\n",
        "        _height = size.find('height')\n",
        "        _height.text = str(expanded_image_dims[1])\n",
        "        \n",
        "        # calculate remapping vector\n",
        "        remap_vector = math.ceil(expanded_image_dims[0]/2 - imagewidth/2), \\\n",
        "                       math.ceil(expanded_image_dims[1]/2 - imageheight/2)\n",
        "    else:\n",
        "        remap_vector = (0, 0)\n",
        "        expansion_factor = 1\n",
        "    \n",
        "    # get box coordinates for each object \n",
        "    for object in root.findall('object'):\n",
        "        bndbox = object.find('bndbox')\n",
        "        Xmin_ = bndbox.find('xmin')\n",
        "        Xmin = int(Xmin_.text)\n",
        "        Ymin_ = bndbox.find('ymin')\n",
        "        Ymin = int(Ymin_.text)\n",
        "        Xmax_ = bndbox.find('xmax')\n",
        "        Xmax = int(Xmax_.text)\n",
        "        Ymax_ = bndbox.find('ymax')\n",
        "        Ymax = int(Ymax_.text)\n",
        "\n",
        "        # calculate centre of object\n",
        "        obj_centre = (Xmax/2 + Xmin/2), (Ymax/2 + Ymin/2)\n",
        "        ox, oy = rotation_centre[0], rotation_centre[1]\n",
        "\n",
        "        # apply rotation and remap to expanded image\n",
        "        Xobjcentr1 = math.cos(theta) * (obj_centre[0]-ox) - math.sin(theta) * (obj_centre[1]-oy) + ox + remap_vector[0]\n",
        "        Yobjcentr1 = math.sin(theta) * (obj_centre[0]-ox) + math.cos(theta) * (obj_centre[1]-oy) + oy + remap_vector[1]\n",
        "        \n",
        "        # rebuild bounding box\n",
        "        Xwidth = Xmax - Xmin\n",
        "        Ywidth = Ymax - Ymin\n",
        "        Xmin1 = math.ceil(Xobjcentr1 - Xwidth/2 * expansion_factor)  \n",
        "        Ymin1 = math.ceil(Yobjcentr1 - Ywidth/2 * expansion_factor)      \n",
        "        Xmax1 = math.ceil(Xobjcentr1 + Xwidth/2 * expansion_factor)\n",
        "        Ymax1 = math.ceil(Yobjcentr1 + Ywidth/2 * expansion_factor)\n",
        "\n",
        "        # overwrite old bounding box\n",
        "        Xmin_.text = str(Xmin1)\n",
        "        Ymin_.text = str(Ymin1)\n",
        "        Xmax_.text = str(Xmax1)\n",
        "        Ymax_.text = str(Ymax1)\n",
        "\n",
        "    # remove out-of-bounds objects\n",
        "    if EXPANDED_PHOTO == False:\n",
        "        for object in root.findall('object'):\n",
        "            bndbox = object.find('bndbox')\n",
        "            Xmin_ = bndbox.find('xmin')\n",
        "            Xmax_ = bndbox.find('xmax')\n",
        "            Ymin_ = bndbox.find('ymin')\n",
        "            Ymax_ = bndbox.find('ymax')\n",
        "            if int(Xmin_.text) < 0 or \\\n",
        "            int(Xmax_.text) > imageheight or \\\n",
        "            int(Ymin_.text) < 0 or \\\n",
        "            int(Ymax_.text) > imagewidth: \n",
        "                root.remove(object)\n",
        "\n",
        "    # save copy of rotated xml file with CW_ANGLE prefixed to filename\n",
        "    tree.write(PATH+'/rotated/CW'+str(ANGLE)+'__'+str(filename))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "cix-0D3kxQQ_"
      },
      "source": [
        "# Mirror rotated JPGs on XX axis\n",
        "Gives equivalent anti-clockwise rotation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "CIswRBAGxDMF"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output/rotated'\n",
        "\n",
        "# iterate through rotated images\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.JPG'): continue\n",
        "    \n",
        "    # apply XX flip, save and prefix filename with ACW\n",
        "    img = cv2.imread(PATH +'/'+ filename)\n",
        "    img_flip_ud = cv2.flip(img, 0)\n",
        "    cv2.imwrite(path +'/A'+str(filename), img_flip_ud)\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_zTrB2oIyznT"
      },
      "source": [
        "# Mirror rotated XML label files on XX axis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "HQVJNqaWxxUa"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import xml.etree.ElementTree as ET\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output/rotated'\n",
        "\n",
        "# iterate through xml files\n",
        "for filename in os.listdir(PATH):\n",
        "    if not filename.endswith('.xml'): continue\n",
        "    fullname = os.path.join(PATH, filename)\n",
        "    tree = ET.parse(fullname)\n",
        "    root = tree.getroot()\n",
        "\n",
        "    # add ACW prefix to linked jpg reference\n",
        "    filename_ = root.find('filename')\n",
        "    newfn = 'A'+str(filename_.text)\n",
        "    filename_.text = str(newfn)\n",
        "    print(str(newfn))\n",
        "\n",
        "    # add ACW prefix to linked jpg path\n",
        "    path_ = root.find('path')\n",
        "    newpath = path_.text[:-12] +str(newfn)+'.xml'\n",
        "    path_.text = str(newpath)\n",
        "\n",
        "    # get image height\n",
        "    imageheight = int(root[4][1].text)\n",
        "    print('height:',imageheight)\n",
        "\n",
        "    # iterate object bounding boxes and apply XX flip\n",
        "    for object in root.findall('object'):\n",
        "        bndbox = object.find('bndbox')\n",
        "        Ymin_ = bndbox.find('ymin')\n",
        "        Ymax_ = bndbox.find('ymax')\n",
        "        Ymin_1 = imageheight-int(Ymax_.text)\n",
        "        Ymax_1 = imageheight-int(Ymin_.text)\n",
        "        print(Ymin_.text, Ymax_.text,' >>> ', Ymin_1, Ymax_1)\n",
        "        Ymin_.text = str(Ymin_1)\n",
        "        Ymax_.text = str(Ymax_1)\n",
        "\n",
        "    # save xml file with ACW prefix to filename\n",
        "    tree.write(path+'/A'+str(filename))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "okUmtm5jVh1-"
      },
      "source": [
        "# Move rotated files to same folder as non-rotated\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "aAZdguIIVooX"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "SOURCE = 'rotated'\n",
        "\n",
        "os.chdir(PATH)\n",
        "for filename in os.listdir(SOURCE):\n",
        "    shutil.move(os.path.join(SOURCE, filename), PATH)\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EAt9BUz2do8m"
      },
      "source": [
        "# Renumber file pairs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "0jrw2atOduzK"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition//skin data/tiled output'\n",
        "\n",
        "# iterate through xml files\n",
        "count = 1\n",
        "for name in os.listdir(PATH):\n",
        "    if name.endswith('.xml'):\n",
        "        \n",
        "        # rename file in format 00001.xml\n",
        "        new_name = str(count).zfill(5) +'.xml'\n",
        "        os.rename(os.path.join(PATH, name), os.path.join(PATH, new_name))\n",
        "        \n",
        "        # find matching jpg file and give matching name 00001.jpg etc\n",
        "        imagename = name[:-4] +'.JPG'\n",
        "        new_imagename = str(count).zfill(5) +'.JPG'\n",
        "        os.rename(os.path.join(path, imagename), os.path.join(path, new_imagename))\n",
        "        count += 1\n",
        "\n",
        "print('finished')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WzXlCJrxosnA"
      },
      "source": [
        "# Move JPGs and XMLs to separate folders"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "ObZe-INKo6cn"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "PATH = '/content/drive/My Drive/Colab Notebooks/HD_object_recognition/Mask_RCNN/skin data'\n",
        "SOURCE = 'tiled output'\n",
        "ANN_DEST = 'annots'\n",
        "IM_DEST = 'images'\n",
        "\n",
        "# create folder to recieve files\n",
        "os.chdir(PATH)\n",
        "if not os.path.exists(IM_DEST):\n",
        "    os.mkdir(IM_DEST)\n",
        "if not os.path.exists(ANN_DEST):\n",
        "    os.mkdir(ANN_DEST)\n",
        "\n",
        "# move files\n",
        "for filename in os.listdir(SOURCE):\n",
        "    if filename.endswith('.xml'):\n",
        "        shutil.move(os.path.join(SOURCE, filename), os.path.join(PATH, ANN_DEST))\n",
        "\n",
        "for filename in os.listdir(SOURCE):\n",
        "    if filename.endswith('.JPG'):\n",
        "        shutil.move(os.path.join(SOURCE, filename), os.path.join(PATH, IM_DEST))\n",
        "\n",
        "print('finished')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyNf9YTX2dTHrMC734bkFuq9",
      "collapsed_sections": [],
      "include_colab_link": true,
      "mount_file_id": "14jYQF2sNhfOOaufbXqN-4MayBz3WYCZl",
      "name": "PascalVOC Tiling and Augmentation.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}