image_preprocessing_cropping.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from imutils import contours\n",
    "from skimage import measure\n",
    "import numpy as np\n",
    "import argparse\n",
    "import imutils\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import pandas as pd\n",
    "from PIL import Image, ImageOps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "239571\n"
     ]
    }
   ],
   "source": [
    "# set path to folder with galaxy images\n",
    "path = 'D:\\\\Kathrin\\\\AstroXDataSience\\\\Data\\\\photometric_jpeg_26.12.21\\\\'\n",
    "\n",
    "# set file to write Images for which errors occur\n",
    "errorfile = open(path + \"..\\\\img_preprocessing_error_log.txt\", \"w\")\n",
    "\n",
    "# make directory for resized images\n",
    "try:\n",
    "    os.makedirs(path + '..\\\\resized')\n",
    "except:\n",
    "    print(\"Folder for resized images already exists\") \n",
    "\n",
    "# choose all images in the folder\n",
    "optical_jpegs = np.array(os.listdir(path))\n",
    "print(len(optical_jpegs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resize_with_padding(img, expected_size):\n",
    "    img.thumbnail((expected_size[0], expected_size[1]))\n",
    "    # print(img.size)\n",
    "    delta_width = expected_size[0] - img.size[0]\n",
    "    delta_height = expected_size[1] - img.size[1]\n",
    "    pad_width = delta_width // 2\n",
    "    pad_height = delta_height // 2\n",
    "    padding = (pad_width, pad_height, delta_width - pad_width, delta_height - pad_height)\n",
    "    return ImageOps.expand(img, padding, fill='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 0\n",
    "\n",
    "for pic in optical_jpegs:\n",
    "    try:\n",
    "        counter += 1\n",
    "        if(counter % 1000 == 0):\n",
    "            print(counter, \" of \", len(optical_jpegs))\n",
    "        image = cv2.imread(path + pic)\n",
    "        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
    "        blurred = cv2.GaussianBlur(gray, (11, 11), 0)\n",
    "\n",
    "        # threshold the image to reveal light regions in the blurred image\n",
    "        thresh = cv2.threshold(blurred, 40, 255, cv2.THRESH_BINARY)[1]\n",
    "\n",
    "        # perform a series of erosions and dilations to remove\n",
    "        # any small blobs of noise from the thresholded image\n",
    "        thresh = cv2.erode(thresh, None, iterations=2)\n",
    "        thresh = cv2.dilate(thresh, None, iterations=4)\n",
    "\n",
    "        # perform a connected component analysis on the thresholded\n",
    "        # image, then initialize a mask to store only the \"large\"\n",
    "        # components\n",
    "        labels = measure.label(thresh, connectivity=2, background=0)\n",
    "        mask = np.zeros(thresh.shape, dtype=\"uint8\")\n",
    "\n",
    "        # loop over the unique components\n",
    "        for label in np.unique(labels):\n",
    "            # if this is the background label which is 0, ignore it\n",
    "            if label == 0:\n",
    "                continue\n",
    "            # otherwise, construct the label mask and count the number of pixels \n",
    "            labelMask = np.zeros(thresh.shape, dtype=\"uint8\")\n",
    "            labelMask[labels == label] = 255\n",
    "            numPixels = cv2.countNonZero(labelMask)\n",
    "\n",
    "            # if the number of pixels in the component is sufficiently\n",
    "            # large, then add it to our mask of \"large blobs\"\n",
    "            if numPixels > 200:\n",
    "                mask = cv2.add(mask, labelMask)\n",
    "\n",
    "            # find the contours in the mask\n",
    "            cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "            cnts = imutils.grab_contours(cnts)\n",
    "\n",
    "            # define the center pixel\n",
    "            center_pixel = (image.shape[0]/2, image.shape[1]/2)\n",
    "\n",
    "            # compute all blobs and choose the one that is closest to center\n",
    "            for (i, c) in enumerate(cnts):\n",
    "                # compute the boundig box for all blobs\n",
    "                (x, y, w, h) = cv2.boundingRect(c)\n",
    "\n",
    "                # cover the object with minimum area\n",
    "                ((cX, cY), radius) = cv2.minEnclosingCircle(c)\n",
    "\n",
    "                # choose only the object to which the center pixel belongs\n",
    "                if(x < center_pixel[0] and center_pixel[0] < (x+w) and y < center_pixel[1] and center_pixel[1] < (y+h)):\n",
    "                    to_crop = c\n",
    "\n",
    "        (x, y, w, h) = cv2.boundingRect(to_crop)\n",
    "        ((cX, cY), radius) = cv2.minEnclosingCircle(to_crop)\n",
    "\n",
    "        # Masking the image with a tolerance\n",
    "        circle_mask = np.zeros(image.shape[:2], dtype=\"uint8\")\n",
    "        cv2.circle(circle_mask, (int(cX), int(cX)), int(radius+20), (255, 255, 255), -1)\n",
    "        masked = cv2.bitwise_and(image, image, mask=circle_mask)\n",
    "\n",
    "        # Cropping the image with a tolerance\n",
    "        cropped = masked[y-20:y+h+20, x-20:x+w+20]\n",
    "\n",
    "        img = Image.fromarray(cropped, 'RGB')\n",
    "        resized = resize_with_padding(img, (200, 200))\n",
    "        plt.axis('off')\n",
    "        plt.imshow(cv2.cvtColor(np.array(resized), cv2.COLOR_BGR2RGB))\n",
    "        plt.savefig(path+'..\\\\resized\\\\' + pic, dpi=300, pad_inches=0, bbox_inches='tight', transparent=True)\n",
    "\n",
    "    except:\n",
    "        error = \"There was an error at picture \" + pic\n",
    "        errorfile.write(error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}