GT_to_COCO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get the output.manifest file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import boto3\n",
    "\n",
    "\n",
    "JOBNAME = '' #Replace it with the labeling job name\n",
    "REGION = ''\n",
    "client = boto3.client('sagemaker',region_name=REGION)\n",
    "\n",
    "response = client.describe_labeling_job(LabelingJobName= JOBNAME)\n",
    "file = response['LabelingJobOutput']['OutputDatasetS3Uri']\n",
    "output_manifest = ntpath.basename(file)\n",
    "!aws s3 cp $file ./"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read the manifest file line by line and create \"Images\" key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Replace the file name with your downloaded manifest file\n",
    "file_name = \"./\" + output_manifest\n",
    "\n",
    "\n",
    "import json\n",
    "import ntpath\n",
    "data_objs  = []\n",
    "input_files = []\n",
    "images = []\n",
    "\n",
    "#Assuming all images are reshaped to have the same dimensions\n",
    "height = 3956\n",
    "width = 5280\n",
    "\n",
    "with open(file_name) as out_manifest:\n",
    "    for line in out_manifest:\n",
    "        data_objs.append(json.loads(line))\n",
    "\n",
    "for line in data_objs:\n",
    "        input_files.append(ntpath.basename(line['source-ref']))\n",
    "      \n",
    "images_key = { \n",
    "              \"coco_url\": \"\",\n",
    "              \"date_captured\": \"\",\n",
    "              \"flickr_url\": \"\",\n",
    "              \"license\": 0,\n",
    "              \"id\": 0,\n",
    "              \"file_name\": \"\",\n",
    "              \"height\": height,\n",
    "              \"width\": width\n",
    "             }    \n",
    "    \n",
    "for img_id, input_file in enumerate(input_files):\n",
    "    images_key[\"file_name\"] = input_file\n",
    "    images_key[\"id\"] = img_id\n",
    "    images.append(images_key.copy())\n",
    "images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identify and Get Categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "categories = []\n",
    "classnamesids= []\n",
    "ids = []\n",
    "names = []\n",
    "mapping = {}\n",
    "cat_hex_map = []\n",
    "\n",
    "category = {\n",
    "      \"id\": '',\n",
    "      \"name\": '',\n",
    "      \"supercategory\": \"\"\n",
    "            }\n",
    "\n",
    "for key in data_objs[0][JOBNAME + '-ref-metadata']['internal-color-map']:\n",
    "    classname = data_objs[0][JOBNAME + '-ref-metadata']['internal-color-map'][key]['class-name']\n",
    "    hexcolor = data_objs[0][JOBNAME + '-ref-metadata']['internal-color-map'][key]['hex-color']\n",
    "    \n",
    "    \n",
    "    if classname == 'BACKGROUND':\n",
    "        continue\n",
    "    else:\n",
    "        classnamesids.append((key, classname))\n",
    "        mapping.update({hexcolor: key})\n",
    "\n",
    "for idd, classname in classnamesids:   \n",
    "    category['id'] = idd\n",
    "    category['name'] = classname\n",
    "    categories.append(category.copy())   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other static variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "licenses =  [\n",
    "    {\n",
    "      \"name\": \"\",\n",
    "      \"id\": 0,\n",
    "      \"url\": \"\"\n",
    "    }\n",
    "  ]\n",
    "info =  {\n",
    "    \"contributor\": \"\",\n",
    "    \"date_created\": \"2020-01-23\",\n",
    "    \"description\": \"test\",\n",
    "    \"url\": \"\",\n",
    "    \"version\": 3,\n",
    "    \"year\": \"2020\"\n",
    "  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to generate segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "from pycocotools import mask\n",
    "from skimage import measure\n",
    "\n",
    "from skimage import io\n",
    "\n",
    "def generate_segmentation(img, category_id, idd, image_id):\n",
    "    seg_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    seg_img = np.uint8(seg_img)\n",
    "\n",
    "    f_bmask = np.asfortranarray(seg_img)\n",
    "    encoded_GT = mask.encode(f_bmask)\n",
    "    area_GT = mask.area(encoded_GT)\n",
    "    bb_GT = mask.toBbox(encoded_GT)\n",
    "    contours = measure.find_contours(seg_img, 0.5)\n",
    "    annotation = {\n",
    "            \"category_id\": category_id,\n",
    "            \"id\": idd,\n",
    "            \"image_id\": image_id,\n",
    "            \"iscrowd\": 0,\n",
    "            \"segmentation\": [],\n",
    "            \"area\": area_GT.tolist(),\n",
    "            \"bbox\": bb_GT.tolist(),\n",
    "        }\n",
    "\n",
    "    for contour in contours:\n",
    "        contour = np.flip(contour, axis=1)\n",
    "        segmentation = contour.ravel().tolist()\n",
    "        annotation[\"segmentation\"].append(segmentation)\n",
    "    return annotation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download the mask output from S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import time\n",
    "annotations = []\n",
    "\n",
    "\n",
    "path = \"/\".join(data_objs[0][JOBNAME+'-ref'].split(\"/\")[:-1]) + \"/\"\n",
    "!aws s3 cp --recursive $path ./output_mask/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate segmentation data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "import matplotlib\n",
    "from skimage import io\n",
    "from skimage.viewer import ImageViewer\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.color import rgb2gray\n",
    "\n",
    "\n",
    "\n",
    "#for subdir, dirs, files in os.walk('output_mask'):\n",
    "'''for data_obj in data_objs:\n",
    "    ntpath.basename(data_obj[JOBNAME + '-ref'])\n",
    "    all_annotations = []'''\n",
    "idd = 0\n",
    "all_annotations = []\n",
    "annotations = []\n",
    "for image_id, file in enumerate(data_objs):\n",
    "    \n",
    "    img_file = 'output_mask/'+ntpath.basename(file[JOBNAME + '-ref']) #subdir + os.sep + file\n",
    "    print(img_file)\n",
    "    a = io.imread(img_file,plugin='matplotlib')\n",
    "    colors = np.unique(a.reshape(-1, a.shape[2]), axis=0)\n",
    "    segments = []\n",
    "    for i in range(colors.shape[0]):\n",
    "        if colors[i][:-1].mean() < 1:\n",
    "            segments.append(colors[i])\n",
    "    \n",
    "    for idds, seg in enumerate(range(len(segments))):\n",
    "\n",
    "        color_hex = matplotlib.colors.to_hex(segments[seg])\n",
    "        category_id = mapping[color_hex]\n",
    "        img = io.imread(img_file, plugin='matplotlib')\n",
    "        msk = segments[seg]  \n",
    "        masked_img = cv2.inRange(img, msk, msk)\n",
    "        \n",
    "        if len(segments) > 1:\n",
    "            img[masked_img>0]=(255,255,255)\n",
    "        annot = generate_segmentation(img,category_id, idd, image_id)\n",
    "        idd+=1\n",
    "        annotations.append(annot)\n",
    "    #print(len(annotations[0]))\n",
    "    #all_annotations.append(annotations[0])\n",
    "print(annotations)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construct the input COCO file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COCO_json = {\n",
    "    \"licenses\": licenses,\n",
    "    \"info\": info,\n",
    "    \"categories\": categories,\n",
    "    \"images\": images,\n",
    "    \"annotations\": annotations\n",
    "    \n",
    "}\n",
    "with open('COCO_file.json', 'w') as json_file:\n",
    "        json.dump(COCO_json, json_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TEST and Visualize Each unique category segmentation\n",
    "\n",
    "This section is from https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoDemo.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from pycocotools.coco import COCO\n",
    "import numpy as np\n",
    "import skimage.io as io\n",
    "import matplotlib.pyplot as plt\n",
    "import pylab\n",
    "pylab.rcParams['figure.figsize'] = (20.0, 10.0)\n",
    "\n",
    "annFile='COCO_file.json'\n",
    "coco=COCO(annFile)\n",
    "# display COCO categories and supercategories\n",
    "cats = coco.loadCats(coco.getCatIds())\n",
    "nms=[cat['name'] for cat in cats]\n",
    "print('COCO categories: \\n{}\\n'.format(' '.join(nms)))\n",
    "\n",
    "nms = set([cat['supercategory'] for cat in cats])\n",
    "print('COCO supercategories: \\n{}'.format(' '.join(nms)))\n",
    "\n",
    "\n",
    "catIds = coco.getCatIds(catNms=['bike','motorbike']);\n",
    "imgIds = coco.getImgIds(catIds=catIds );\n",
    "imgIds = coco.getImgIds(imgIds = [1]) #<<<<<<<<<<<< Change the number for different test images\n",
    "img = coco.loadImgs(imgIds[np.random.randint(0,len(imgIds))])[0]\n",
    "print(img)\n",
    "\n",
    "I = io.imread(img['file_name'])\n",
    "h, w, c = I.shape\n",
    "print(h)\n",
    "print(w)\n",
    "plt.axis('off')\n",
    "plt.imshow(I)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(I); plt.axis('off')\n",
    "annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None)\n",
    "anns = coco.loadAnns(annIds)\n",
    "coco.showAnns(anns)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXPERIMENTS:  to lower the  numbers of seg values (Don't run)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=np.array(annotation[\"segmentation\"][0])\n",
    "\n",
    "tol = 2\n",
    "\n",
    "'''unique_tol = A[~(np.triu(np.abs(A[:,None] - A) <= tol,1)).any(0)]\n",
    "unique_tol'''\n",
    "uniq_seg = np.unique(np.floor(tol*A)/tol)\n",
    "indexes = np.unique(np.floor(tol*A)/tol, return_index=True)[1]\n",
    "values = [A[index] for index in sorted(indexes)]\n",
    "#annotation[\"segmentation\"][0] = values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print and show the segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pycocotools.coco as coco\n",
    "from pycocotools.coco import COCO\n",
    "import cv2\n",
    "\n",
    "for annotation in annotations:\n",
    "    with open('data.json', 'w') as json_file:\n",
    "        json.dump(annotation, json_file)\n",
    "    coco=COCO('data.json')\n",
    "    I = io.imread('./Downloads/multi-orig.jpeg')\n",
    "\n",
    "    #I = cv2.resize(I,(300, 225))\n",
    "\n",
    "    plt.imshow(I)\n",
    "    coco.showAnns([annotation])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage import io\n",
    "from skimage.viewer import ImageViewer\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.color import rgb2gray\n",
    "\n",
    "\n",
    "a = io.imread(base64.decodebytes(img_data), plugin='imageio')\n",
    "grayscale = rgb2gray(a)\n",
    "grayscale[grayscale > 0] = 1\n",
    "plt.imshow(a)\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}