{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Sartorius: Manipulating Train Data\n\n### Abstract\n\nThis is a subsection created to complete the Sartorious competition. Our team have decided to create extra sets of the train data images to increase the total number of images being trained by our model. Since there is a train csv file that contains the annotations for each of the images in this competition, we had applied the Right Angle Mirror Concept to duplicate the images and create its annotations at the same time.\n\n### Introduction\nOne of the methods to increase the accuracy of on the test data results is by increasing the training data. In the train folder, there are a total of 606 images. The train csv file indicates that all of the images have the same 704 width and 520 height. Since the height and width are not the same, the Right Angle Mirror Concept was applied to create a reflection of the original images.\n\nBased on the image formation in plane mirror article from Physics Classroom's website, each of the train image will create three extra sets of reflected images. The figure below is an example on how the concept is applied to the train image.\n\n![RightAngleMirror.PNG](attachment:c0dfce22-9489-41c2-bd54-29433f697b14.PNG)\n\nImagine you have the original image on the top right corner with two plane mirror placed at 90 degree. With the two mirrors, there will be three extra 'fake' images created out of it. Thus, at the end of this section, we will have 3 sets of 'fake' images for each of the 606 original images.\n\n### Import Relevant Packages\nIn this segment, all package which are needed to create the fake images are imported.\n","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"},"attachments":{"c0dfce22-9489-41c2-bd54-29433f697b14.PNG":{"image/png":"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"}}},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nfrom cv2 import imread\nfrom matplotlib import image\nfrom matplotlib import pyplot\n\nimport PIL\nfrom PIL import Image\nprint('Pillow Version: ', PIL.__version__)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:42.915573Z","iopub.execute_input":"2021-12-26T22:09:42.916241Z","iopub.status.idle":"2021-12-26T22:09:43.172572Z","shell.execute_reply.started":"2021-12-26T22:09:42.916125Z","shell.execute_reply":"2021-12-26T22:09:43.171507Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Manipulate Images\n#### Part A: Sample Image Flipping\nIn this section, a sample image is used to have a better view on how the 'fake' images can be created. The original train images are not used in this section as the output images is much harder to identify the changes. All train images will be flipped in the Part B.","metadata":{}},{"cell_type":"code","source":"# load the image\nimage = Image.open('../input/test-original-image/TEST_ori.PNG')\n\n# load image as pixel array\ndata = imread('../input/test-original-image/TEST_ori.PNG')\n# summarize shape of the pixel array\nprint(data.shape)\n\n# display the array of pixels as an image\npyplot.imshow(data)\npyplot.show()","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:53.243259Z","iopub.execute_input":"2021-12-26T22:09:53.243556Z","iopub.status.idle":"2021-12-26T22:09:53.517945Z","shell.execute_reply.started":"2021-12-26T22:09:53.243521Z","shell.execute_reply":"2021-12-26T22:09:53.516904Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Horizontal flip (using Original Image) - Creating Fake Image 1\nfi1 = image.transpose(Image.FLIP_LEFT_RIGHT)\n# save in png format\nfi1.save('TEST_fi1.png')\n# load image as pixel array\ndata1 = imread('TEST_fi1.png')\n# summarize shape of the pixel array\nprint(data1.shape)\n# display the array of pixels as an image\npyplot.imshow(data1)\npyplot.show()","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:55.03293Z","iopub.execute_input":"2021-12-26T22:09:55.033251Z","iopub.status.idle":"2021-12-26T22:09:55.353323Z","shell.execute_reply.started":"2021-12-26T22:09:55.033217Z","shell.execute_reply":"2021-12-26T22:09:55.352285Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Vertical flip (using Original Image)- Creating Fake Image 2\nfi2 = image.transpose(Image.FLIP_TOP_BOTTOM)\n# save in png format\nfi2.save('TEST_fi2.png')\n# load image as pixel array\ndata2 = imread('TEST_fi2.png')\n# summarize shape of the pixel array\nprint(data2.shape)\n# display the array of pixels as an image\npyplot.imshow(data2)\npyplot.show()","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:56.376796Z","iopub.execute_input":"2021-12-26T22:09:56.377635Z","iopub.status.idle":"2021-12-26T22:09:56.588446Z","shell.execute_reply.started":"2021-12-26T22:09:56.377596Z","shell.execute_reply":"2021-12-26T22:09:56.587591Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Vertical flip (using Fake Image 1) - Creating Fake Image 3\nfi3 = fi1.transpose(Image.FLIP_TOP_BOTTOM)\n# save in png format\nfi3.save('TEST_fi3.png')\n# load image as pixel array\ndata3 = imread('TEST_fi3.png')\n# summarize shape of the pixel array\nprint(data3.shape)\n# display the array of pixels as an image\npyplot.imshow(data3)\npyplot.show()","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:57.556793Z","iopub.execute_input":"2021-12-26T22:09:57.557361Z","iopub.status.idle":"2021-12-26T22:09:57.780866Z","shell.execute_reply.started":"2021-12-26T22:09:57.557308Z","shell.execute_reply":"2021-12-26T22:09:57.780263Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# View all images\naxarr = pyplot.figure(figsize=(500,500))\nf, axarr = pyplot.subplots(2,2)\naxarr[0,0].imshow(data)\naxarr[0,1].imshow(data1)\naxarr[1,0].imshow(data2)\naxarr[1,1].imshow(data3)\n","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:09:58.66022Z","iopub.execute_input":"2021-12-26T22:09:58.660831Z","iopub.status.idle":"2021-12-26T22:10:02.73485Z","shell.execute_reply.started":"2021-12-26T22:09:58.660768Z","shell.execute_reply":"2021-12-26T22:10:02.733876Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"From the results above, the sample image is successfully flipped three times to create the fake image. A 'for' loop will be used in Part B to flip all the images.\n\n#### Part B: Flip all Train Images","metadata":{}},{"cell_type":"code","source":"# Import dataframe\ndf_train = pd.read_csv('../input/sartorius-cell-instance-segmentation/train.csv')\n# Show the first few rows of the dataframe\ndf_train.head()","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:10:07.538018Z","iopub.execute_input":"2021-12-26T22:10:07.538312Z","iopub.status.idle":"2021-12-26T22:10:08.196352Z","shell.execute_reply.started":"2021-12-26T22:10:07.53828Z","shell.execute_reply":"2021-12-26T22:10:08.195776Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Get all the unique IDs\nimage_names = df_train['id'].unique()\nprint('First Three IDs: ', image_names[:3],\n      '\\nLength of Array: ', len(image_names))","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:10:10.020755Z","iopub.execute_input":"2021-12-26T22:10:10.021543Z","iopub.status.idle":"2021-12-26T22:10:10.040182Z","shell.execute_reply.started":"2021-12-26T22:10:10.021503Z","shell.execute_reply":"2021-12-26T22:10:10.039348Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Check if all the names of the images have the same length\n# This will be helpful to change update the names later\nfor i in image_names:\n    if len(i) != 12 :\n        print('False')\nprint('All the same length!')","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:10:12.023178Z","iopub.execute_input":"2021-12-26T22:10:12.023477Z","iopub.status.idle":"2021-12-26T22:10:12.029401Z","shell.execute_reply.started":"2021-12-26T22:10:12.023446Z","shell.execute_reply":"2021-12-26T22:10:12.028425Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# All Original Images will be save with original name + '0' (eg: '0030fd0e63780.png' is the new name for the original image)\n# All Fake Image 1 will be save with original name + '1' (eg: '0030fd0e63781.png')\n# All Fake Image 2 will be save with original name + '2' (eg: '0030fd0e63782.png')\n# All Fake Image 3 will be save with original name + '3' (eg: '0030fd0e63783.png')\n\nnumstr = ['0', '1', '2', '3']\ndirname = '../input/sartorius-cell-instance-segmentation/train/'\nimage_format = '.png'\n\nfor i in image_names :\n    fpath = (dirname.__add__(i)).__add__(image_format)\n    image = Image.open(fpath)\n    \n    # Horizontal flip (using Original Image) - Creating Fake Image 1\n    fi1 = image.transpose(Image.FLIP_LEFT_RIGHT)\n    # Vertical flip (using Original Image)- Creating Fake Image 2\n    fi2 = image.transpose(Image.FLIP_TOP_BOTTOM)\n    # Vertical flip (using Fake Image 1) - Creating Fake Image 3\n    fi3 = fi1.transpose(Image.FLIP_TOP_BOTTOM)\n    \n    # save in png format\n    image.save((i.__add__(numstr[0])).__add__(image_format))\n    fi1.save((i.__add__(numstr[1])).__add__(image_format))\n    fi2.save((i.__add__(numstr[2])).__add__(image_format))\n    fi3.save((i.__add__(numstr[3])).__add__(image_format))\nprint('Complete!')","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:10:13.05214Z","iopub.execute_input":"2021-12-26T22:10:13.052774Z","iopub.status.idle":"2021-12-26T22:11:45.880638Z","shell.execute_reply.started":"2021-12-26T22:10:13.052733Z","shell.execute_reply":"2021-12-26T22:11:45.879302Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Create Annotations\n\n#### Part A: Create Functions - Expand & Shrink","metadata":{"execution":{"iopub.status.busy":"2021-12-08T01:30:17.444688Z","iopub.execute_input":"2021-12-08T01:30:17.445167Z","iopub.status.idle":"2021-12-08T01:30:17.452097Z","shell.execute_reply.started":"2021-12-08T01:30:17.445118Z","shell.execute_reply":"2021-12-08T01:30:17.450952Z"}}},{"cell_type":"code","source":"def expand(los) :\n    '''\n    This function will expand the counts original annotation in the file into its original pixels.\n    Example: expand('100 2') -> [100 101]\n    '''\n    loi = list(map(int, los.split()))\n    newlist = []\n\n    loc = 0 # Current Location/ Index\n    list_len = len(loi)\n\n    while list_len > 0:\n        count = 0\n        while loi[loc+1] > 0:\n            newlist.append(loi[loc] + count)\n            count +=1\n            loi[loc+1] -= 1\n        loc += 2\n        list_len -= 2\n    return(newlist)\n\n    \ntest1 = '100 1 150 3 189 5 197 4'\nexpand(test1)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:11:58.470576Z","iopub.execute_input":"2021-12-26T22:11:58.472875Z","iopub.status.idle":"2021-12-26T22:11:58.48333Z","shell.execute_reply.started":"2021-12-26T22:11:58.472684Z","shell.execute_reply":"2021-12-26T22:11:58.482626Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def shrink(loi):\n    '''\n    This function will shrink the pixels using count as per annotation.\n    Example: shrink([100 101]) -> '100 2'\n    '''\n    newlist = [loi[0]]\n    nl_loc = 0\n    current = newlist[nl_loc]\n    loi_loc = 1\n    loi_len = len(loi)\n    count = 1\n    \n    while loi_len > 0:   \n        if loi_len == 1:\n            newlist.append(count)\n            \n        if loi_len >1 and loi[loi_loc] - (current+count-1) ==  1:\n            count += 1\n\n        elif loi_len > 1 and loi[loi_loc] - (current+count-1) >  1:\n            newlist.append(count)\n            newlist.append(loi[loi_loc])\n            nl_loc = len(newlist)-1\n            current = newlist[nl_loc]\n            count = 1\n        \n        loi_loc += 1\n        loi_len -= 1\n    return(\" \".join(map(str,newlist)))\n\ntest2 = [1, 5, 100, 150, 151, 152, 189, 190, 191, 192, 193, 197, 198, 199, 200, 300]\nshrink(test2)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:01.817821Z","iopub.execute_input":"2021-12-26T22:12:01.818331Z","iopub.status.idle":"2021-12-26T22:12:01.83094Z","shell.execute_reply.started":"2021-12-26T22:12:01.818263Z","shell.execute_reply":"2021-12-26T22:12:01.830088Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Part B: Row & Column Min, Max\nIn this section, we will create list for column min, column max, row min and row max. Then, use the created list to search for the min max of a certain pixel, which is the find function.\n\nBefore creating the list, we need to check the pixel starts from 0 or 1.","metadata":{}},{"cell_type":"code","source":"# Use the original annotations to see if the pixels starts from 1 to 366080 or from 0 to 366079.\nalist = df_train.annotation[:]\n\nfor i in alist:\n    if '366080' in i:\n        print('It Exist!')\nprint('Done')","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:05.417827Z","iopub.execute_input":"2021-12-26T22:12:05.418378Z","iopub.status.idle":"2021-12-26T22:12:05.462765Z","shell.execute_reply.started":"2021-12-26T22:12:05.418345Z","shell.execute_reply":"2021-12-26T22:12:05.461971Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Use two empty lists to store the first values of each row and the last values of each row.\n# These two lists will be used to create the annotation for the flip images.\nrow_min = []\nrow_max = []\nheight = 1\nwhile height != 521:\n    row_min.append(704*(height-1)+1)\n    row_max.append(704*height)\n    height += 1\n    \n# Print the last few values in each list\nprint(row_min[:5])\nprint(row_max[515:])","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:19.056102Z","iopub.execute_input":"2021-12-26T22:12:19.056425Z","iopub.status.idle":"2021-12-26T22:12:19.06434Z","shell.execute_reply.started":"2021-12-26T22:12:19.056391Z","shell.execute_reply":"2021-12-26T22:12:19.063169Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Use two empty lists to store the first values of each column and the last values of each column.\n# These two lists will be used to create the annotation for the flip images.\ncol_min = []\ncol_max = []\nwidth = 1\nwhile width != 705:\n    col_min.append(width)\n    col_max.append(365377+width-1)\n    width += 1\n    \n# Print the last four values in each list\nprint(col_min[700:])\nprint(col_max[:3])","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:11.314009Z","iopub.execute_input":"2021-12-26T22:12:11.314778Z","iopub.status.idle":"2021-12-26T22:12:11.321589Z","shell.execute_reply.started":"2021-12-26T22:12:11.314734Z","shell.execute_reply":"2021-12-26T22:12:11.320794Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def find(number):\n    '''\n    Find the minimum and maximum values of each column and row, then return the list with these four values.\n    Example : find(1) -> [1, 520, 1, 704]\n    '''\n    number -=1\n    r = max(0, number//704)\n    c = max(0, number%704)\n    i =0\n    for i in col_min:\n        if number > i : \n            i += 1\n        else: \n            i\n    alist = [col_min[c], col_max[c], row_min[r], row_max[r]]\n    return(alist)\n\nprint(find(1))\nprint(find(2))","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:22.375343Z","iopub.execute_input":"2021-12-26T22:12:22.375761Z","iopub.status.idle":"2021-12-26T22:12:22.383561Z","shell.execute_reply.started":"2021-12-26T22:12:22.375722Z","shell.execute_reply":"2021-12-26T22:12:22.382672Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Print same sample min max of columns and rows","metadata":{}},{"cell_type":"code","source":"print('366080 = ', find(366080), '\\n520 = ',find(520), '\\n704 = ',find(704), '\\n705 = ',find(705),)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:25.08518Z","iopub.execute_input":"2021-12-26T22:12:25.085595Z","iopub.status.idle":"2021-12-26T22:12:25.092107Z","shell.execute_reply.started":"2021-12-26T22:12:25.085564Z","shell.execute_reply":"2021-12-26T22:12:25.091487Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Part C: Create Annotation for the fake images\n\nIn this section, the functions to create annotations for the fake images. We just needs functions for fake image 1 and fake image 2. The function for fake image 3 is much easier since it can be created using the first two functions.","metadata":{}},{"cell_type":"code","source":"# Define constant variables\ncmin = 0\ncmax = 1\nrmin = 2\nrmax = 3\n\ndef fake1(los):\n    '''\n    Create annotation for fake image 1\n    Example: fake1('1 2') -> '703 2'\n    '''\n    loi = expand(los)\n    alist = []\n    for i in loi :\n        info = find(i)\n        value = info[rmax] - i + info[rmin]\n        alist.append(value)\n    alist.sort()\n    return shrink(alist)\n\ntest3 = '1 2 704 1 1000 3 366080 1'\nfake1(test3)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:30.990691Z","iopub.execute_input":"2021-12-26T22:12:30.991343Z","iopub.status.idle":"2021-12-26T22:12:31.002033Z","shell.execute_reply.started":"2021-12-26T22:12:30.9913Z","shell.execute_reply":"2021-12-26T22:12:31.001169Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def fake2(los):\n    '''\n    Create annotation for fake image 2\n    Example: fake1('1 2') -> '365377 2'\n    '''\n    loi = expand(los)\n    alist = []\n    for i in loi :\n        info = find(i)\n        value = info[cmax] - i + info[cmin]\n        alist.append(value)\n    alist.sort()\n    return shrink(alist)\n\ntest4 = '1 2'\nfake2(test4)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:32.810851Z","iopub.execute_input":"2021-12-26T22:12:32.811688Z","iopub.status.idle":"2021-12-26T22:12:32.819852Z","shell.execute_reply.started":"2021-12-26T22:12:32.811647Z","shell.execute_reply":"2021-12-26T22:12:32.818987Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def fake3 (los):\n    temp = fake1(los)\n    return fake2(temp)\n\nfake3(test4)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:12:35.229015Z","iopub.execute_input":"2021-12-26T22:12:35.229757Z","iopub.status.idle":"2021-12-26T22:12:35.237606Z","shell.execute_reply.started":"2021-12-26T22:12:35.229708Z","shell.execute_reply":"2021-12-26T22:12:35.236706Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"data0 = df_train[['id','annotation']]\nprint(data0)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:13:45.280742Z","iopub.execute_input":"2021-12-26T22:13:45.281152Z","iopub.status.idle":"2021-12-26T22:13:45.29175Z","shell.execute_reply.started":"2021-12-26T22:13:45.281121Z","shell.execute_reply":"2021-12-26T22:13:45.290818Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"column_names = [\"ID\", \"Annotation\"]\ndf_rev = pd.DataFrame(columns = column_names)\n\nfor index, row in data0.iterrows():\n    name = row['id']\n    loc = row['annotation']\n    \n    for j in numstr:\n        if j == '0':\n            a_name = name+numstr[0]\n            a_loc = loc\n        if j == '1':\n            a_name = name+numstr[1]\n            a_loc = fake1(loc)\n        if j == '2':\n            a_name = name+numstr[2]\n            a_loc = fake2(loc)\n        if j == '3':\n            a_name = name+numstr[3]\n            a_loc = fake3(loc)\n        df_rev = df_rev.append({'ID': a_name, 'Annotation': a_loc}, ignore_index=True)\nprint(df_rev)","metadata":{"execution":{"iopub.status.busy":"2021-12-26T22:13:47.360644Z","iopub.execute_input":"2021-12-26T22:13:47.360972Z","iopub.status.idle":"2021-12-26T22:13:47.60004Z","shell.execute_reply.started":"2021-12-26T22:13:47.360939Z","shell.execute_reply":"2021-12-26T22:13:47.598965Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# saving the dataframe\ndf_rev.to_csv('newdf.csv')","metadata":{"_kg_hide-input":true,"_kg_hide-output":true,"execution":{"iopub.status.busy":"2021-12-26T22:14:24.91413Z","iopub.execute_input":"2021-12-26T22:14:24.914794Z","iopub.status.idle":"2021-12-26T22:14:24.919559Z","shell.execute_reply.started":"2021-12-26T22:14:24.914699Z","shell.execute_reply":"2021-12-26T22:14:24.918643Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Reference\nThePhysicsClassroom. (2021).Reflection and the Ray Model of Light - Lesson 2 - Image Formation in Plane Mirrors. Retrieved on December 5, 2021,from https://www.physicsclassroom.com/class/refln/Lesson-2/Right-Angle-Mirrors","metadata":{}}]}