color-clustering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from matplotlib import pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.cluster import KMeans, AffinityPropagation\n",
    "import colorsys\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create output folders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "if not os.path.exists('figures'):\n",
    "    os.mkdir('figures')\n",
    "if not os.path.exists('results'):\n",
    "    os.mkdir('results')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hexencode(rgb):\n",
    "    \"\"\"Transform an RGB tuple to a hex string (html color)\"\"\"\n",
    "    r=int(rgb[0])\n",
    "    g=int(rgb[1])\n",
    "    b=int(rgb[2])\n",
    "    return '#%02x%02x%02x' % (r,g,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![palette](img/color_palettes_23_0.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open('img/color_palettes_23_0.png')  # Taken from: http://seaborn.pydata.org/tutorial/color_palettes.html\n",
    "w, h = im.size\n",
    "colors = im.getcolors(w*h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check that the sum of colors match the number of pixels\n",
    "assert sum([colors[i][0] for i in range(len(colors))]) == w*h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, c in enumerate(colors):\n",
    "    plt.bar(idx, c[0], color=hexencode(c[1]), lw=1, ec='k')\n",
    "plt.ylabel('Pixels')\n",
    "plt.xlabel('Color')\n",
    "plt.savefig('figures/color-hist.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load image and create histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# im = Image.open('img/bricks.png')\n",
    "im = Image.open('img/bricks-scaled.png')\n",
    "w, h = im.size\n",
    "colors = im.getcolors(w*h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![bricks](img/bricks-scaled.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check that the sum of colors match the number of pixels\n",
    "assert sum([colors[i][0] for i in range(len(colors))]) == w*h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below takes a long time to run and is not needed for the remaining code to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14,6))\n",
    "for idx, c in enumerate(colors):\n",
    "    plt.bar(idx, c[0], color=hexencode(c[1]), lw=0, width=1)\n",
    "plt.axis([0, len(colors), 0, 60])\n",
    "plt.ylabel('Pixels')\n",
    "plt.xlabel('Color')\n",
    "plt.savefig('figures/color-hist-2.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot individual colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(\n",
    "    data={\n",
    "        'pixels': [colors[i][0] for i in range(len(colors))],\n",
    "        'R': [colors[i][1][0] for i in range(len(colors))],\n",
    "        'G': [colors[i][1][1] for i in range(len(colors))],\n",
    "        'B': [colors[i][1][2] for i in range(len(colors))],\n",
    "        'alpha': [colors[i][1][3] for i in range(len(colors))],\n",
    "        'hex': [hexencode(colors[i][1]) for i in range(len(colors))]\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 6))\n",
    "plt.subplot(121)\n",
    "plt.scatter(x=df.R, y=df.B, s=30, c=df.hex, alpha=.6, edgecolor='k', lw=0.3)\n",
    "plt.axis([0, 255, 0, 255])\n",
    "plt.xlabel('Red', fontsize=14)\n",
    "plt.ylabel('Blue', fontsize=14)\n",
    "plt.subplot(122)\n",
    "plt.scatter(x=df.G, y=df.B, s=40, c=df.hex, alpha=.6, edgecolor='k', lw=0.3)\n",
    "plt.axis([0, 255, 0, 255])\n",
    "plt.xlabel('Green', fontsize=14)\n",
    "plt.ylabel('Blue', fontsize=14)\n",
    "plt.savefig('figures/rgb-proj.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.R\n",
    "y = df.G\n",
    "z = df.B\n",
    "c = df.hex\n",
    "s = 30\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.6, edgecolor='k', lw=0.3)\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "plt.savefig('figures/rgb-scatter.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.R\n",
    "y = df.G\n",
    "z = df.B\n",
    "c = df.hex\n",
    "s = df.pixels * 15\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.6, edgecolor='k', lw=0.3)\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "plt.savefig('figures/rgb-scatter2.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RGB k-means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeans = KMeans(n_clusters=4, random_state=0, n_init=10).fit(df[['R', 'G', 'B']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['kcenter'] = kmeans.labels_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate weighted average of RBG color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_col = np.zeros((kmeans.n_clusters, 3))\n",
    "for c in range(kmeans.n_clusters):\n",
    "    temp_df = df[df.kcenter == c]\n",
    "    avg_col[c, 0] = np.average(temp_df.R, weights=temp_df.pixels)\n",
    "    avg_col[c, 1] = np.average(temp_df.B, weights=temp_df.pixels)\n",
    "    avg_col[c, 2] = np.average(temp_df.G, weights=temp_df.pixels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate weighted average of HSV color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hsv_matrix = np.zeros((len(df), 3))\n",
    "\n",
    "for i in range(len(df)):\n",
    "    hsv_matrix[i] = colorsys.rgb_to_hsv(r=df.R[i]/255, g=df.G[i]/255, b=df.B[i]/255)\n",
    "    \n",
    "df['h'] = hsv_matrix[:, 0]\n",
    "df['s'] = hsv_matrix[:, 1]\n",
    "df['v'] = hsv_matrix[:, 2]\n",
    "\n",
    "avg_col2 = np.zeros((kmeans.n_clusters, 3))\n",
    "for c in range(kmeans.n_clusters):\n",
    "    temp_df = df[df.kcenter == c]\n",
    "    avg_col2[c, 0], avg_col2[c, 1], avg_col2[c, 2] = colorsys.hsv_to_rgb(h=np.average(temp_df.h, weights=temp_df.pixels),\n",
    "                                                                         s=np.average(temp_df.s, weights=temp_df.pixels),\n",
    "                                                                         v=np.average(temp_df.v, weights=temp_df.pixels))\n",
    "avg_col2 *= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16, 6))\n",
    "ax = fig.add_subplot(131, projection='3d')\n",
    "\n",
    "x = kmeans.cluster_centers_[:, 0]\n",
    "y = kmeans.cluster_centers_[:, 1]\n",
    "z = kmeans.cluster_centers_[:, 2]\n",
    "c = [hexencode(kmeans.cluster_centers_[i,:]) for i in range(kmeans.n_clusters)]\n",
    "s = 300\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1)\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "ax.set_title('RGB K-means', fontsize=16)\n",
    "\n",
    "\n",
    "ax = fig.add_subplot(132, projection='3d')\n",
    "x = avg_col[:, 0]\n",
    "y = avg_col[:, 1]\n",
    "z = avg_col[:, 2]\n",
    "c = [hexencode(r) for r in avg_col]\n",
    "s = 300\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1)\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "ax.set_title('Weighted average RGB', fontsize=16)\n",
    "\n",
    "\n",
    "ax = fig.add_subplot(133, projection='3d')\n",
    "x = avg_col2[:, 0]\n",
    "y = avg_col2[:, 1]\n",
    "z = avg_col2[:, 2]\n",
    "c = [hexencode(r) for r in avg_col2]\n",
    "s = 300\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1)\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "ax.set_title('Weighted average HSV', fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.R\n",
    "y = df.G\n",
    "z = df.B\n",
    "c = df.hex\n",
    "s = 30\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.6, edgecolor='k', lw=0.3)\n",
    "\n",
    "\n",
    "x = kmeans.cluster_centers_[:, 0]\n",
    "y = kmeans.cluster_centers_[:, 1]\n",
    "z = kmeans.cluster_centers_[:, 2]\n",
    "c = [hexencode(kmeans.cluster_centers_[i,:]) for i in range(kmeans.n_clusters)]\n",
    "s = 1600\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1, marker='o')\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HSV k-means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeansHSV = KMeans(n_clusters=4, random_state=0, n_init=10).fit(df[['h', 's', 'v']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfHSV = df.copy()\n",
    "dfHSV['kcenter'] = kmeansHSV.labels_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HSVcenters = np.zeros((kmeansHSV.n_clusters, 3))\n",
    "for i in range(kmeansHSV.n_clusters):\n",
    "    HSVcenters[i, :] = colorsys.hsv_to_rgb(h=kmeansHSV.cluster_centers_[i, 0],\n",
    "                                           s=kmeansHSV.cluster_centers_[i, 1],\n",
    "                                           v=kmeansHSV.cluster_centers_[i, 2])\n",
    "HSVcenters *= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = kmeans.cluster_centers_[:, 0]\n",
    "y = kmeans.cluster_centers_[:, 1]\n",
    "z = kmeans.cluster_centers_[:, 2]\n",
    "c = [hexencode(kmeans.cluster_centers_[i,:]) for i in range(kmeans.n_clusters)]\n",
    "s = 400\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1)\n",
    "\n",
    "\n",
    "x = HSVcenters[:, 0]\n",
    "y = HSVcenters[:, 1]\n",
    "z = HSVcenters[:, 2]\n",
    "c = [hexencode(HSVcenters[i,:]) for i in range(kmeansHSV.n_clusters)]\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=1, edgecolor='k', lw=1, marker='s')\n",
    "\n",
    "ax.set_xlim3d(0, 255)\n",
    "ax.set_ylim3d(0, 255)\n",
    "ax.set_zlim3d(0, 255)\n",
    "ax.set_xlabel('Red', fontsize=14)\n",
    "ax.set_ylabel('Green', fontsize=14)\n",
    "ax.set_zlabel('Blue', fontsize=14)\n",
    "ax.set_title('Comparison of K-means', fontsize=16)\n",
    "ax.legend(['RGB k-means', 'HSV k-means'], scatterpoints=1, frameon=False, fontsize=13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HSV plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.h\n",
    "y = df.s\n",
    "z = df.v\n",
    "c = df.hex\n",
    "s = 30\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.6, edgecolor='k', lw=0.3)\n",
    "\n",
    "# ax.set_xlim3d(0, 255)\n",
    "# ax.set_ylim3d(0, 255)\n",
    "# ax.set_zlim3d(0, 255)\n",
    "\n",
    "ax.set_xlabel('H', fontsize=14)\n",
    "ax.set_ylabel('S', fontsize=14)\n",
    "ax.set_zlabel('V', fontsize=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = df.h\n",
    "y = df.s\n",
    "z = df.v\n",
    "c = df.hex\n",
    "s = 30\n",
    "\n",
    "plt.scatter(x, y, c=c, s=s, alpha=.6, edgecolor='k', lw=0.3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[['h', 's', 'v']].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Circular plot of HSV\n",
    "\n",
    "![HSV plot](http://www.tech-faq.com/wp-content/uploads/2009/02/hsv.jpeg)\n",
    "http://www.tech-faq.com/hsv.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circ_y = df.s*np.sin(df.h*2*np.pi)\n",
    "circ_x = df.s*np.cos(df.h*2*np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(16,6))\n",
    "ax = plt.subplot(121)\n",
    "plt.scatter(circ_x, circ_y, s=40, alpha = .25, c=df.hex, lw=0)\n",
    "ax.tick_params(\n",
    "    axis='both',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    labelbottom=False,\n",
    "    left=False,\n",
    "    labelleft=False)\n",
    "plt.xlabel('x', fontsize=20)\n",
    "plt.ylabel('y', fontsize=20)\n",
    "\n",
    "ax = plt.subplot(122)\n",
    "plt.scatter(df.v*circ_x, df.v*circ_y, s=40, alpha = .25, c=df.hex, lw=0)\n",
    "ax.tick_params(\n",
    "    axis='both',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    labelbottom=False,\n",
    "    left=False,\n",
    "    labelleft=False)\n",
    "plt.xlabel('x', fontsize=20)\n",
    "plt.ylabel('y', fontsize=20)\n",
    "\n",
    "plt.savefig('figures/hsv-proj.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.v*df.s*np.sin(df.h*2*np.pi)\n",
    "y = df.v*df.s*np.cos(df.h*2*np.pi)\n",
    "z = df.v\n",
    "c = df.hex\n",
    "s = 30\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.2, edgecolor='k', lw=0)\n",
    "\n",
    "ax.set_xlim3d(-1, 1)\n",
    "ax.set_ylim3d(-1, 1)\n",
    "ax.set_zlim3d(0, 1)\n",
    "\n",
    "# ax.set_xlabel('H', fontsize=14)\n",
    "# ax.set_ylabel('S', fontsize=14)\n",
    "ax.set_zlabel('V', fontsize=14)\n",
    "\n",
    "ax.tick_params(\n",
    "    axis='x',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    labelbottom=False)\n",
    "ax.tick_params(\n",
    "    axis='y',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    right=False,\n",
    "    left=False,\n",
    "    labelbottom=False,\n",
    "    labelright=False,\n",
    "    labelleft=False)\n",
    "\n",
    "plt.savefig('figures/hsv-scatter.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cut = df[df.v > 0.40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = cut.v*cut.s*np.sin(cut.h*2*np.pi)\n",
    "y = cut.v*cut.s*np.cos(cut.h*2*np.pi)\n",
    "z = cut.v\n",
    "c = cut.hex\n",
    "s = 30\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.2, edgecolor='k', lw=0)\n",
    "\n",
    "ax.set_xlim3d(-1, 1)\n",
    "ax.set_ylim3d(-1, 1)\n",
    "ax.set_zlim3d(0, 1)\n",
    "\n",
    "# ax.set_xlabel('H', fontsize=14)\n",
    "# ax.set_ylabel('S', fontsize=14)\n",
    "ax.set_zlabel('V', fontsize=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotly plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotly.offline import init_notebook_mode, iplot\n",
    "import plotly.graph_objs as go\n",
    "init_notebook_mode(connected=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RGB\n",
    "\n",
    "Interactive plot of individual colors and cluster centers for RGB decomposition. Compare cluster centers with weighted average color within each cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_centers = np.zeros((kmeans.n_clusters, 3))\n",
    "for c in range(kmeans.n_clusters):\n",
    "    weighted_cluster_centers[c] = np.average(df[df['kcenter'] == c][['R', 'G', 'B']], weights=df[df['kcenter'] == c]['pixels'], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = df.R\n",
    "y = df.G\n",
    "z = df.B\n",
    "c = df.hex\n",
    "\n",
    "trace1 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=6,\n",
    "        color=c,\n",
    "        opacity=0.25),\n",
    "    name='Individual colors')\n",
    "\n",
    "x = kmeans.cluster_centers_[:, 0]\n",
    "y = kmeans.cluster_centers_[:, 1]\n",
    "z = kmeans.cluster_centers_[:, 2]\n",
    "c = [hexencode(kmeans.cluster_centers_[i,:]) for i in range(kmeans.n_clusters)]\n",
    "\n",
    "trace2 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=c,\n",
    "        opacity=1),\n",
    "    name='k-means center')\n",
    "\n",
    "x = weighted_cluster_centers[:, 0]\n",
    "y = weighted_cluster_centers[:, 1]\n",
    "z = weighted_cluster_centers[:, 2]\n",
    "c = [hexencode(kmeans.cluster_centers_[i,:]) for i in range(kmeans.n_clusters)]\n",
    "trace3 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=\"#aa00aa\",\n",
    "        opacity=1),\n",
    "    name='weighted center')\n",
    "\n",
    "data = [trace1, trace2, trace3]\n",
    "layout = go.Layout(margin=dict(l=0, r=0, b=0, t=0))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "_ = iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HSV\n",
    "\n",
    "Interactive plot of individual colors and cluster centers for HSV decomposition. Compare cluster centers with weighted average color within each cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_centers = np.zeros((kmeansHSV.n_clusters, 3))\n",
    "for c in range(kmeansHSV.n_clusters):\n",
    "    # weighted_cluster_centers[c] = dfHSV[dfHSV['kcenter'] == c].mean()[['h', 's', 'v']].values\n",
    "    weighted_cluster_centers[c] = np.average(dfHSV[dfHSV['kcenter'] == c][['h', 's', 'v']], weights=dfHSV[dfHSV['kcenter'] == c]['pixels'], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_center_colors = np.zeros((kmeansHSV.n_clusters, 3))\n",
    "for i in range(kmeansHSV.n_clusters):\n",
    "    weighted_cluster_center_colors[i] = colorsys.hsv_to_rgb(\n",
    "        h=weighted_cluster_centers[i, 0],\n",
    "        s=weighted_cluster_centers[i, 1],\n",
    "        v=weighted_cluster_centers[i, 2])\n",
    "weighted_cluster_center_colors *= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dfHSV.v * dfHSV.s * np.sin(dfHSV.h * 2 * np.pi)\n",
    "y = dfHSV.v * dfHSV.s * np.cos(dfHSV.h * 2 * np.pi)\n",
    "z = dfHSV.v\n",
    "c = dfHSV.hex\n",
    "\n",
    "trace1 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=6,\n",
    "        color=c,\n",
    "        opacity=0.25),\n",
    "    name='Individual colors')\n",
    "\n",
    "x = kmeansHSV.cluster_centers_[:, 2] * kmeansHSV.cluster_centers_[:, 1] * np.sin(kmeansHSV.cluster_centers_[:, 0] * 2 * np.pi)\n",
    "y = kmeansHSV.cluster_centers_[:, 2] * kmeansHSV.cluster_centers_[:, 1] * np.cos(kmeansHSV.cluster_centers_[:, 0] * 2 * np.pi)\n",
    "z = kmeansHSV.cluster_centers_[:, 2]\n",
    "c = [hexencode(HSVcenters[i,:]) for i in range(kmeansHSV.n_clusters)]\n",
    "\n",
    "trace2 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=c,\n",
    "        opacity=1),\n",
    "    name='k-means center')\n",
    "\n",
    "x = weighted_cluster_centers[:, 2] * weighted_cluster_centers[:, 1] * np.sin(weighted_cluster_centers[:, 0] * 2 * np.pi)\n",
    "y = weighted_cluster_centers[:, 2] * weighted_cluster_centers[:, 1] * np.cos(weighted_cluster_centers[:, 0] * 2 * np.pi)\n",
    "z = weighted_cluster_centers[:, 2]\n",
    "c = [hexencode(weighted_cluster_center_colors[i]) for i in range(kmeansHSV.n_clusters)]\n",
    "\n",
    "trace3 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=\"#aa00aa\",\n",
    "        opacity=1),\n",
    "    name='weighted center')\n",
    "\n",
    "data = [trace1, trace2, trace3]\n",
    "layout = go.Layout(margin=dict(l=0, r=0, b=0, t=0))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "_ = iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## k-means on transformed HSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfHSV2 = dfHSV.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transform H and S to polar coordinates before clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfHSV2['hx'] = dfHSV2.s * np.sin(dfHSV2.h * 2 * np.pi)\n",
    "dfHSV2['hy'] = dfHSV2.s * np.cos(dfHSV2.h * 2 * np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeansHSV2 = KMeans(n_clusters=4, random_state=0, n_init=10).fit(dfHSV2[['hx', 'hy', 'v']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfHSV2['kcenter'] = kmeansHSV2.labels_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HSVcenters2 = np.zeros((kmeansHSV2.n_clusters, 3))\n",
    "for i in range(kmeansHSV2.n_clusters):\n",
    "    HSVcenters2[i, :] = colorsys.hsv_to_rgb(h=kmeansHSV2.cluster_centers_[i, 0],\n",
    "                                           s=kmeansHSV2.cluster_centers_[i, 1],\n",
    "                                           v=kmeansHSV2.cluster_centers_[i, 2])\n",
    "HSVcenters2 *= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_centers2 = np.zeros((kmeansHSV2.n_clusters, 3))\n",
    "for c in range(kmeansHSV.n_clusters):\n",
    "    weighted_cluster_centers2[c] = np.average(dfHSV2[dfHSV2['kcenter'] == c][['h', 's', 'v']], weights=dfHSV2[dfHSV2['kcenter'] == c]['pixels'], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_center_colors2 = np.zeros((kmeansHSV2.n_clusters, 3))\n",
    "for i in range(kmeansHSV2.n_clusters):\n",
    "    weighted_cluster_center_colors2[i] = colorsys.hsv_to_rgb(\n",
    "        h=weighted_cluster_centers2[i, 0],\n",
    "        s=weighted_cluster_centers2[i, 1],\n",
    "        v=weighted_cluster_centers2[i, 2])\n",
    "weighted_cluster_center_colors2 *= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dfHSV2.v * dfHSV2.s * np.sin(dfHSV2.h * 2 * np.pi)\n",
    "y = dfHSV2.v * dfHSV2.s * np.cos(dfHSV2.h * 2 * np.pi)\n",
    "z = dfHSV2.v\n",
    "c = dfHSV2.hex\n",
    "\n",
    "trace1 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=6,\n",
    "        color=c,\n",
    "        opacity=0.25),\n",
    "    name='Individual colors')\n",
    "\n",
    "x = kmeansHSV2.cluster_centers_[:, 2] * kmeansHSV2.cluster_centers_[:, 0]\n",
    "y = kmeansHSV2.cluster_centers_[:, 2] * kmeansHSV2.cluster_centers_[:, 1]\n",
    "z = kmeansHSV2.cluster_centers_[:, 2]\n",
    "c = [hexencode(HSVcenters2[i,:]) for i in range(kmeansHSV2.n_clusters)]\n",
    "\n",
    "trace2 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=\"#aa00aa\",\n",
    "        opacity=1),\n",
    "    name='k-means center')\n",
    "\n",
    "x = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.sin(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "y = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.cos(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "z = weighted_cluster_centers2[:, 2]\n",
    "c = [hexencode(weighted_cluster_center_colors2[i]) for i in range(kmeansHSV2.n_clusters)]\n",
    "\n",
    "trace3 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=16,\n",
    "        color=c,\n",
    "        opacity=1),\n",
    "    name='weighted center')\n",
    "\n",
    "data = [trace1, trace2, trace3]\n",
    "layout = go.Layout(margin=dict(l=0, r=0, b=0, t=0))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "_ = iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dfHSV2.v * dfHSV2.s * np.sin(dfHSV2.h * 2 * np.pi)\n",
    "y = dfHSV2.v * dfHSV2.s * np.cos(dfHSV2.h * 2 * np.pi)\n",
    "z = dfHSV2.v\n",
    "c = dfHSV2.hex\n",
    "\n",
    "trace1 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=6,\n",
    "        color=c,\n",
    "        opacity=0.2),\n",
    "    name='Individual colors')\n",
    "\n",
    "x = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.sin(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "y = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.cos(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "z = weighted_cluster_centers2[:, 2]\n",
    "c = [hexencode(weighted_cluster_center_colors2[i]) for i in range(kmeansHSV2.n_clusters)]\n",
    "\n",
    "trace3 = go.Scatter3d(\n",
    "    x=x,\n",
    "    y=y,\n",
    "    z=z,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=18,\n",
    "        color=c,\n",
    "        opacity=1),\n",
    "    name='Dominant colors')\n",
    "\n",
    "data = [trace1, trace3]\n",
    "layout = go.Layout(margin=dict(l=0, r=0, b=0, t=0))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "_ = iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final 3D plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_cluster_centers2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = df.v*df.s*np.sin(df.h*2*np.pi)\n",
    "y = df.v*df.s*np.cos(df.h*2*np.pi)\n",
    "z = df.v\n",
    "c = df.hex\n",
    "s = 30\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=s, alpha=.2, edgecolor='k', lw=0)\n",
    "\n",
    "x = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.sin(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "y = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.cos(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "z = weighted_cluster_centers2[:, 2]\n",
    "c = [hexencode(weighted_cluster_center_colors2[i]) for i in range(kmeansHSV2.n_clusters)]\n",
    "\n",
    "ax.scatter(x, y, z, c=c, s=1000, alpha=1, edgecolor='k', lw=1)\n",
    "\n",
    "#ax.set_xlim3d(-1, 1)\n",
    "#ax.set_ylim3d(-1, 1)\n",
    "#ax.set_zlim3d(0, 1)\n",
    "\n",
    "# ax.set_xlabel('H', fontsize=14)\n",
    "# ax.set_ylabel('S', fontsize=14)\n",
    "ax.set_zlabel('V', fontsize=14)\n",
    "\n",
    "ax.tick_params(\n",
    "    axis='x',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    labelbottom=False)\n",
    "ax.tick_params(\n",
    "    axis='y',\n",
    "    which='both',\n",
    "    bottom=False,\n",
    "    top=False,\n",
    "    right=False,\n",
    "    left=False,\n",
    "    labelbottom=False,\n",
    "    labelright=False,\n",
    "    labelleft=False)\n",
    "\n",
    "plt.savefig('figures/hsv-scatter-centers.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save data for plotlyjs plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "decimals = 3  # less precision, and faster loading for browser plotting\n",
    "\n",
    "data_array = pd.DataFrame(data={\n",
    "    'x': np.round(dfHSV2.v * dfHSV2.s * np.sin(dfHSV2.h * 2 * np.pi), decimals),\n",
    "    'y': np.round(dfHSV2.v * dfHSV2.s * np.cos(dfHSV2.h * 2 * np.pi), decimals),\n",
    "    'z': np.round(dfHSV2.v, decimals),\n",
    "    'c': dfHSV2.hex\n",
    "})\n",
    "data_array.to_csv('results/cluster-data.csv', index=False)\n",
    "\n",
    "x = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.sin(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "y = weighted_cluster_centers2[:, 2] * weighted_cluster_centers2[:, 1] * np.cos(weighted_cluster_centers2[:, 0] * 2 * np.pi)\n",
    "z = weighted_cluster_centers2[:, 2]\n",
    "c = [hexencode(weighted_cluster_center_colors2[i]) for i in range(kmeansHSV2.n_clusters)]\n",
    "\n",
    "dominant_array = pd.DataFrame(data={\n",
    "    'x2': np.round(x, decimals),\n",
    "    'y2': np.round(y, decimals),\n",
    "    'z2': np.round(z, decimals),\n",
    "    'c2': c\n",
    "})\n",
    "dominant_array.to_csv('results/dominant-data.csv', index=False)\n",
    "\n",
    "# Combine and save\n",
    "data_array.join(dominant_array).to_csv('results/combined.csv', index=False)"
   ]
  }
 ],
 "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "849px",
    "left": "0px",
    "right": "1647px",
    "top": "107px",
    "width": "273px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}