05 - Visual numpy using images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Images as Numpy Arrays\n",
    "\n",
    "Images, being a 2D structure of pixel values, are especially suited for getting familiar with Numpy syntax and operations in a fun and interactive way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following is a Jupyter 'magic' command that tells it to insert plots right within the notebook.\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.image import imread\n",
    "\n",
    "# Set the default size of any plots we generate, in inches\n",
    "plt.rcParams['figure.figsize'] = (10, 6)\n",
    "\n",
    "# Read a PNG image into a Numpy Array\n",
    "img = imread('images/map.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic inspection of what we got back by reading the PNG file\n",
    "\n",
    "print(type(img))\n",
    "print(img)\n",
    "print(img.ndim)\n",
    "print(img.shape)\n",
    "print(img.max())\n",
    "print(img.min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Displaying an image using Matplotlib\n",
    "plt.imshow(img, cmap='gray', vmin=0, vmax=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice that the image is especially poor in contrast. Can we do something about it?\n",
    "\n",
    "# Increase Contrast Range\n",
    "pixel_min_value = img.min()\n",
    "pixel_range = img.max() - img.min()\n",
    "img_normalized = (img - pixel_min_value) / pixel_range\n",
    "plt.imshow(img_normalized, cmap='gray', vmin=0, vmax=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic inspection of normalized array\n",
    "\n",
    "print(img_normalized.ndim)\n",
    "print(img_normalized.shape)\n",
    "print(img_normalized.max())\n",
    "print(img_normalized.min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot a histogram of the original and normalized images\n",
    "img_values = img.flatten()\n",
    "plt.hist(img_values, alpha=0.6)\n",
    "img_normalized_values = img_normalized.flatten()\n",
    "plt.hist(img_normalized_values, alpha=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All pixel values are between 0 and 1\n",
    "# Is 0 Black and 1 white, or vice versa?\n",
    "# Let's find out!\n",
    "\n",
    "blank_image = np.ones(img.shape)\n",
    "plt.imshow(blank_image, cmap='gray', vmin=0, vmax=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Color images - notice the shape of the resulting matrix, which is 3d instead of 2d\n",
    "cezanne = imread('images/cezanne.png')\n",
    "print(cezanne.ndim)\n",
    "print(cezanne.shape)\n",
    "print(cezanne.max())\n",
    "print(cezanne.min())\n",
    "print(cezanne[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display the image\n",
    "plt.imshow(cezanne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's extract the Blue/Green/Red channel values of the image into separate numpy arrays\n",
    "reds = cezanne[:, :, 0]\n",
    "blues = cezanne[:, :, 1]\n",
    "greens = cezanne[:, :, 2]\n",
    "\n",
    "# We'll add 3 subplots to our figure\n",
    "# With 1 row and 3 columns of subplots, and with a shared Y-axis\n",
    "# We get back two things:\n",
    "#     The figure object\n",
    "#     A tuple of 'Axes' objects, each corresponding to an individual subplot\n",
    "# So the axes object here has 3 axis inside it\n",
    "f, axes = plt.subplots(1, 3, sharey=True)\n",
    "\n",
    "# The 'Super Title' of the figure, common to all subplots\n",
    "f.suptitle('RGB Histograms')\n",
    "\n",
    "# For each of the axes, plot a histogram of the R/G/B channel values\n",
    "axes[0].hist(reds.flatten())\n",
    "axes[1].hist(blues.flatten())\n",
    "axes[2].hist(greens.flatten())\n",
    "\n",
    "# Can we change the color of the plots to correspond to the channel they represent?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's mess with the Red channel, and modify all values in the red channel to 1\n",
    "# Notice the use of 'ones_like' (there's also 'zeros_like')\n",
    "reds = np.ones_like(reds)\n",
    "\n",
    "# We use the 'dstack' method here to stack the 3 numpy arrays 'depth-wise'\n",
    "# Notice that we also have 'hstack', and 'vstack' (horizontal-stacking and vertical-stacking respectively)\n",
    "red_cezanne = np.dstack((reds, blues, greens))\n",
    "\n",
    "# It's invaluable to look at the shape of the array at every point to ensure there are no surprises\n",
    "print(red_cezanne.shape)\n",
    "plt.imshow(red_cezanne)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}