slic1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SLIC:\n",
    "    def __init__(self, img, step, nc):\n",
    "        self.img = img\n",
    "        self.height, self.width = img.shape[:2]\n",
    "        self._convertToLAB()\n",
    "        self.step = step\n",
    "        self.nc = nc\n",
    "        self.ns = step\n",
    "        self.FLT_MAX = 1000000\n",
    "        self.ITERATIONS = 10\n",
    "\n",
    "    def _convertToLAB(self):\n",
    "        try:\n",
    "            import cv2\n",
    "            self.labimg = cv2.cvtColor(img, cv2.COLOR_BGR2LAB).astype(np.float64)\n",
    "        except ImportError:\n",
    "            self.labimg = np.copy(self.img)\n",
    "            for i in xrange(self.labimg.shape[0]):\n",
    "                for j in xrange(self.labimg.shape[1]):\n",
    "                    rgb = self.labimg[i, j]\n",
    "                    self.labimg[i, j] = self._rgb2lab(tuple(reversed(rgb)))\n",
    "\n",
    "    def _rgb2lab ( self, inputColor ) :\n",
    "\n",
    "       num = 0\n",
    "       RGB = [0, 0, 0]\n",
    "\n",
    "       for value in inputColor :\n",
    "           value = float(value) / 255\n",
    "\n",
    "           if value > 0.04045 :\n",
    "               value = ( ( value + 0.055 ) / 1.055 ) ** 2.4\n",
    "           else :\n",
    "               value = value / 12.92\n",
    "\n",
    "           RGB[num] = value * 100\n",
    "           num = num + 1\n",
    "\n",
    "       XYZ = [0, 0, 0,]\n",
    "\n",
    "       X = RGB [0] * 0.4124 + RGB [1] * 0.3576 + RGB [2] * 0.1805\n",
    "       Y = RGB [0] * 0.2126 + RGB [1] * 0.7152 + RGB [2] * 0.0722\n",
    "       Z = RGB [0] * 0.0193 + RGB [1] * 0.1192 + RGB [2] * 0.9505\n",
    "       XYZ[ 0 ] = round( X, 4 )\n",
    "       XYZ[ 1 ] = round( Y, 4 )\n",
    "       XYZ[ 2 ] = round( Z, 4 )\n",
    "\n",
    "       XYZ[ 0 ] = float( XYZ[ 0 ] ) / 95.047         # ref_X =  95.047\n",
    "       XYZ[ 1 ] = float( XYZ[ 1 ] ) / 100.0          # ref_Y = 100.000\n",
    "       XYZ[ 2 ] = float( XYZ[ 2 ] ) / 108.883        # ref_Z = 108.883\n",
    "\n",
    "       num = 0\n",
    "       for value in XYZ :\n",
    "\n",
    "           if value > 0.008856 :\n",
    "               value = value ** ( 0.3333333333333333 )\n",
    "           else :\n",
    "               value = ( 7.787 * value ) + ( 16 / 116 )\n",
    "\n",
    "           XYZ[num] = value\n",
    "           num = num + 1\n",
    "\n",
    "       Lab = [0, 0, 0]\n",
    "\n",
    "       L = ( 116 * XYZ[ 1 ] ) - 16\n",
    "       a = 500 * ( XYZ[ 0 ] - XYZ[ 1 ] )\n",
    "       b = 200 * ( XYZ[ 1 ] - XYZ[ 2 ] )\n",
    "\n",
    "       Lab [ 0 ] = round( L, 4 )\n",
    "       Lab [ 1 ] = round( a, 4 )\n",
    "       Lab [ 2 ] = round( b, 4 )\n",
    "\n",
    "       return Lab\n",
    "\n",
    "    def generateSuperPixels(self):\n",
    "        self._initData()\n",
    "        indnp = np.mgrid[0:self.height,0:self.width].swapaxes(0,2).swapaxes(0,1)\n",
    "        for i in range(self.ITERATIONS):\n",
    "            self.distances = self.FLT_MAX * np.ones(self.img.shape[:2])\n",
    "            for j in xrange(self.centers.shape[0]):\n",
    "                xlow, xhigh = int(self.centers[j][3] - self.step), int(self.centers[j][3] + self.step)\n",
    "                ylow, yhigh = int(self.centers[j][4] - self.step), int(self.centers[j][4] + self.step)\n",
    "\n",
    "                if xlow <= 0:\n",
    "                    xlow = 0\n",
    "                if xhigh > self.width:\n",
    "                    xhigh = self.width\n",
    "                if ylow <=0:\n",
    "                    ylow = 0\n",
    "                if yhigh > self.height:\n",
    "                    yhigh = self.height\n",
    "\n",
    "                cropimg = self.labimg[ylow : yhigh , xlow : xhigh]\n",
    "                colordiff = cropimg - self.labimg[self.centers[j][4], self.centers[j][3]]\n",
    "                colorDist = np.sqrt(np.sum(np.square(colordiff), axis=2))\n",
    "\n",
    "                yy, xx = np.ogrid[ylow : yhigh, xlow : xhigh]\n",
    "                pixdist = ((yy-self.centers[j][4])**2 + (xx-self.centers[j][3])**2)**0.5\n",
    "                dist = ((colorDist/self.nc)**2 + (pixdist/self.ns)**2)**0.5\n",
    "\n",
    "                distanceCrop = self.distances[ylow : yhigh, xlow : xhigh]\n",
    "                idx = dist < distanceCrop\n",
    "                distanceCrop[idx] = dist[idx]\n",
    "                self.distances[ylow : yhigh, xlow : xhigh] = distanceCrop\n",
    "                self.clusters[ylow : yhigh, xlow : xhigh][idx] = j\n",
    "\n",
    "            for k in xrange(len(self.centers)):\n",
    "                idx = (self.clusters == k)\n",
    "                colornp = self.labimg[idx]\n",
    "                distnp = indnp[idx]\n",
    "                self.centers[k][0:3] = np.sum(colornp, axis=0)\n",
    "                sumy, sumx = np.sum(distnp, axis=0)\n",
    "                self.centers[k][3:] = sumx, sumy\n",
    "                self.centers[k] /= np.sum(idx)\n",
    "\n",
    "    def _initData(self):\n",
    "        self.clusters = -1 * np.ones(self.img.shape[:2])\n",
    "        self.distances = self.FLT_MAX * np.ones(self.img.shape[:2])\n",
    "\n",
    "        centers = []\n",
    "        for i in xrange(self.step, self.width - self.step/2, self.step):\n",
    "            for j in xrange(self.step, self.height - self.step/2, self.step):\n",
    "                \n",
    "                nc = self._findLocalMinimum(center=(i, j))\n",
    "                color = self.labimg[nc[1], nc[0]]\n",
    "                center = [color[0], color[1], color[2], nc[0], nc[1]]\n",
    "                centers.append(center)\n",
    "        self.center_counts = np.zeros(len(centers))\n",
    "        self.centers = np.array(centers)\n",
    "\n",
    "    def createConnectivity(self):\n",
    "        label = 0\n",
    "        adjlabel = 0\n",
    "        lims = self.width * self.height / self.centers.shape[0]\n",
    "        dx4 = [-1, 0, 1, 0]\n",
    "        dy4 = [0, -1, 0, 1]\n",
    "        new_clusters = -1 * np.ones(self.img.shape[:2]).astype(np.int64)\n",
    "        elements = []\n",
    "        for i in xrange(self.width):\n",
    "            for j in xrange(self.height):\n",
    "                if new_clusters[j, i] == -1:\n",
    "                    elements = []\n",
    "                    elements.append((j, i))\n",
    "                    for dx, dy in zip(dx4, dy4):\n",
    "                        x = elements[0][1] + dx\n",
    "                        y = elements[0][0] + dy\n",
    "                        if (x>=0 and x < self.width and \n",
    "                            y>=0 and y < self.height and \n",
    "                            new_clusters[y, x] >=0):\n",
    "                            adjlabel = new_clusters[y, x]\n",
    "                count = 1\n",
    "                c = 0\n",
    "                while c < count:\n",
    "                    for dx, dy in zip(dx4, dy4):\n",
    "                        x = elements[c][1] + dx\n",
    "                        y = elements[c][0] + dy\n",
    "\n",
    "                        if (x>=0 and x<self.width and y>=0 and y<self.height):\n",
    "                            if new_clusters[y, x] == -1 and self.clusters[j, i] == self.clusters[y, x]:\n",
    "                                elements.append((y, x))\n",
    "                                new_clusters[y, x] = label\n",
    "                                count+=1\n",
    "                    c+=1\n",
    "                if (count <= lims >> 2):\n",
    "                    for c in range(count):\n",
    "                        new_clusters[elements[c]] = adjlabel\n",
    "                    label-=1\n",
    "                label+=1\n",
    "        self.new_clusters = new_clusters\n",
    "\n",
    "    def displayContours(self, color):\n",
    "        dx8 = [-1, -1, 0, 1, 1, 1, 0, -1]\n",
    "        dy8 = [0, -1, -1, -1, 0, 1, 1, 1]\n",
    "\n",
    "        isTaken = np.zeros(self.img.shape[:2], np.bool)\n",
    "        contours = []\n",
    "\n",
    "        for i in xrange(self.width):\n",
    "            for j in xrange(self.height):\n",
    "                nr_p = 0\n",
    "                for dx, dy in zip(dx8, dy8):\n",
    "                    x = i + dx\n",
    "                    y = j + dy\n",
    "                    if x>=0 and x < self.width and y>=0 and y < self.height:\n",
    "                        if isTaken[y, x] == False and self.clusters[j, i] != self.clusters[y, x]:\n",
    "                            nr_p += 1\n",
    "\n",
    "                if nr_p >= 2:\n",
    "                    isTaken[j, i] = True\n",
    "                    contours.append([j, i])\n",
    "\n",
    "        for i in xrange(len(contours)):\n",
    "            self.img[contours[i][0], contours[i][1]] = color\n",
    "\n",
    "    def _findLocalMinimum(self, center):\n",
    "        min_grad = self.FLT_MAX\n",
    "        loc_min = center\n",
    "        for i in xrange(center[0] - 1, center[0] + 2):\n",
    "            for j in xrange(center[1] - 1, center[1] + 2):\n",
    "                c1 = self.labimg[j+1, i]\n",
    "                c2 = self.labimg[j, i+1]\n",
    "                c3 = self.labimg[j, i]\n",
    "                if ((c1[0] - c3[0])**2)**0.5 + ((c2[0] - c3[0])**2)**0.5 < min_grad:\n",
    "                    min_grad = abs(c1[0] - c3[0]) + abs(c2[0] - c3[0])\n",
    "                    loc_min = [i, j]\n",
    "        return loc_min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread(\"dog.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "nr_superpixels = 5\n",
    "nc = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hsubhashis\\Anaconda2\\lib\\site-packages\\ipykernel_launcher.py:94: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future\n"
     ]
    }
   ],
   "source": [
    "step = int((img.shape[0]*img.shape[1]/nr_superpixels)**0.5)\n",
    "\n",
    "slic = SLIC(img, step, nc)\n",
    "slic.generateSuperPixels()\n",
    "slic.createConnectivity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cv2.imshow(\"superpixels\", slic.img)\n",
    "cv2.waitKey(0)\n",
    "cv2.imwrite(\"SLICimg.jpg\", slic.img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}