steganography.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image, ImageChops, ImageOps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "img1 = Image.open('forest.jpg')\n",
    "img2 = Image.open('rickroll.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# img1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# img2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integer_to_binary(rgb):\n",
    "    '''\n",
    "    Convert RGB pixel values from integer to binary\n",
    "    INPUT: An integer tuple (e.g. (220, 110, 96))\n",
    "    OUTPUT: A string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\"))\n",
    "    '''\n",
    "    r, g, b = rgb\n",
    "    return ('{0:08b}'.format(r),\n",
    "            '{0:08b}'.format(g),\n",
    "            '{0:08b}'.format(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_to_integer(rgb):\n",
    "    '''\n",
    "    Convert RGB pixel values from binary to integer.\n",
    "    INPUT: A string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\"))\n",
    "    OUTPUT: Return an int tuple (e.g. (220, 110, 96))\n",
    "    '''\n",
    "    r, g, b = rgb\n",
    "    return (int(r, 2),\n",
    "            int(g, 2),\n",
    "            int(b, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_rgb(rgb1, rgb2):\n",
    "    '''\n",
    "    Merge two RGB pixels using 4 least significant bits.\n",
    "    INPUT: A string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\")),\n",
    "           Another string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\"))\n",
    "    OUTPUT: An integer tuple with the two RGB values merged\n",
    "    '''\n",
    "    r1, g1, b1 = rgb1\n",
    "    r2, g2, b2 = rgb2\n",
    "    rgb = (r1[:4] + r2[:4],\n",
    "           g1[:4] + g2[:4],\n",
    "           b1[:4] + b2[:4])\n",
    "    return rgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge(image1_path, image2_path):\n",
    "    '''\n",
    "    Merge two images. The second one will be merged into the first one.\n",
    "    INPUT: Path to the first image, path to the second image\n",
    "    OUTPUT: A new merged image.\n",
    "    '''\n",
    "    \n",
    "    img1 = Image.open(image1_path)\n",
    "    img2 = Image.open(image2_path)\n",
    "\n",
    "    # Ensure image 1 is larger than image 2\n",
    "    if img2.size[0] > img1.size[0] or img2.size[1] > img1.size[1]:\n",
    "        raise ValueError('Image 1 size is lower than image 2 size!')\n",
    "\n",
    "    # Get the pixel map of the two images\n",
    "    pixel_map1 = img1.load()\n",
    "    pixel_map2 = img2.load()\n",
    "\n",
    "    # Create a new image that will be outputted\n",
    "    new_image = Image.new(img1.mode, img1.size)\n",
    "    pixels_new = new_image.load()\n",
    "\n",
    "    for i in range(img1.size[0]):\n",
    "        for j in range(img1.size[1]):\n",
    "            rgb1 = integer_to_binary(pixel_map1[i, j])\n",
    "\n",
    "            # Use a black pixel as default\n",
    "            rgb2 = integer_to_binary((0, 0, 0))\n",
    "\n",
    "            # Check if the pixel map position is valid for the second image\n",
    "            if i < img2.size[0] and j < img2.size[1]:\n",
    "                rgb2 = integer_to_binary(pixel_map2[i, j])\n",
    "\n",
    "            # Merge the two pixels and convert it to a integer tuple\n",
    "            rgb = merge_rgb(rgb1, rgb2)\n",
    "\n",
    "            pixels_new[i, j] = binary_to_integer(rgb)\n",
    "\n",
    "    new_image.convert('RGB').save('merged.png')\n",
    "    \n",
    "    return new_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unmerge(image_path):\n",
    "    '''\n",
    "    Unmerge an image.\n",
    "    INPUT: The path to the input image.\n",
    "    OUTPUT: The extracted hidden image.\n",
    "    '''\n",
    "    \n",
    "    img = Image.open(image_path)\n",
    "\n",
    "    # Load the pixel map\n",
    "    pixel_map = img.load()\n",
    "\n",
    "    # Create the new image and load the pixel map\n",
    "    new_image = Image.new(img.mode, img.size)\n",
    "    pixels_new = new_image.load()\n",
    "\n",
    "    # Tuple used to store the image original size\n",
    "    original_size = img.size\n",
    "\n",
    "    for i in range(img.size[0]):\n",
    "        for j in range(img.size[1]):\n",
    "            # Get the RGB (as a string tuple) from the current pixel\n",
    "            r, g, b = integer_to_binary(pixel_map[i, j])\n",
    "\n",
    "            # Extract the last 4 bits (corresponding to the hidden image)\n",
    "            # Concatenate 4 zero bits because we are working with 8 bit values\n",
    "            rgb = (r[4:] + \"0000\",\n",
    "                   g[4:] + \"0000\",\n",
    "                   b[4:] + \"0000\")\n",
    "\n",
    "            # Convert it to an integer tuple\n",
    "            pixels_new[i, j] = binary_to_integer(rgb)\n",
    "\n",
    "            # If this is a 'valid' position, store it\n",
    "            # as the last valid position\n",
    "            if pixels_new[i, j] != (0, 0, 0):\n",
    "                original_size = (i + 1, j + 1)\n",
    "\n",
    "    # Crop the image based on the 'valid' pixels\n",
    "    new_image = new_image.crop((0, 0, original_size[0], original_size[1]))\n",
    "\n",
    "    new_image.save('unmerged.png')\n",
    "    \n",
    "    return new_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_image = merge('forest.jpg', 'rickroll.jpg')\n",
    "# merged_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "unmerged_image = unmerge('merged.png')\n",
    "# unmerged_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ImageOps.equalize(ImageChops.subtract(img1, merged_image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ImageOps.equalize(ImageChops.subtract(img2, unmerged_image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_rgb2(rgb1, rgb2):\n",
    "    \"\"\"\n",
    "    Merge two RGB tuples.\n",
    "    :param rgb1: A string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\"))\n",
    "    :param rgb2: Another string tuple (e.g. (\"00101010\", \"11101011\", \"00010110\"))\n",
    "    :return: An integer tuple with the two RGB values merged.\n",
    "    \"\"\"\n",
    "    r1, g1, b1 = rgb1\n",
    "    r2, g2, b2 = rgb2\n",
    "    rgb = (r1[:6] + r2[:2],\n",
    "           g1[:6] + g2[:2],\n",
    "           b1[:6] + b2[:2])\n",
    "    return rgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge2(img1, img2):\n",
    "    \"\"\"\n",
    "    Merge two images. The second one will be merged into the first one.\n",
    "    :param img1: First image\n",
    "    :param img2: Second image\n",
    "    :return: A new merged image.\n",
    "    \"\"\"\n",
    "\n",
    "    # Check the images dimensions\n",
    "    if img2.size[0] > img1.size[0] or img2.size[1] > img1.size[1]:\n",
    "        raise ValueError('Image 1 size is lower than image 2 size!')\n",
    "\n",
    "    # Get the pixel map of the two images\n",
    "    pixel_map1 = img1.load()\n",
    "    pixel_map2 = img2.load()\n",
    "\n",
    "    # Create a new image that will be outputted\n",
    "    new_image = Image.new(img1.mode, img1.size)\n",
    "    pixels_new = new_image.load()\n",
    "\n",
    "    for i in range(img1.size[0]):\n",
    "        for j in range(img1.size[1]):\n",
    "            rgb1 = integer_to_binary(pixel_map1[i, j])\n",
    "\n",
    "            # Use a black pixel as default\n",
    "            rgb2 = integer_to_binary((0, 0, 0))\n",
    "\n",
    "            # Check if the pixel map position is valid for the second image\n",
    "            if i < img2.size[0] and j < img2.size[1]:\n",
    "                rgb2 = integer_to_binary(pixel_map2[i, j])\n",
    "\n",
    "            # Merge the two pixels and convert it to a integer tuple\n",
    "            rgb = merge_rgb2(rgb1, rgb2)\n",
    "\n",
    "            pixels_new[i, j] = binary_to_integer(rgb)\n",
    "\n",
    "    return new_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unmerge2(img):\n",
    "    \"\"\"\n",
    "    Unmerge an image.\n",
    "    :param img: The input image.\n",
    "    :return: The unmerged/extracted image.\n",
    "    \"\"\"\n",
    "\n",
    "    # Load the pixel map\n",
    "    pixel_map = img.load()\n",
    "\n",
    "    # Create the new image and load the pixel map\n",
    "    new_image = Image.new(img.mode, img.size)\n",
    "    pixels_new = new_image.load()\n",
    "\n",
    "    # Tuple used to store the image original size\n",
    "    original_size = img.size\n",
    "\n",
    "    for i in range(img.size[0]):\n",
    "        for j in range(img.size[1]):\n",
    "            # Get the RGB (as a string tuple) from the current pixel\n",
    "            r, g, b = integer_to_binary(pixel_map[i, j])\n",
    "\n",
    "            # Extract the last 4 bits (corresponding to the hidden image)\n",
    "            # Concatenate 4 zero bits because we are working with 8 bit values\n",
    "            rgb = (r[6:] + \"000000\",\n",
    "                   g[6:] + \"000000\",\n",
    "                   b[6:] + \"000000\")\n",
    "\n",
    "            # Convert it to an integer tuple\n",
    "            pixels_new[i, j] = binary_to_integer(rgb)\n",
    "\n",
    "            # If this is a 'valid' position, store it\n",
    "            # as the last valid position\n",
    "            if pixels_new[i, j] != (0, 0, 0):\n",
    "                original_size = (i + 1, j + 1)\n",
    "\n",
    "    # Crop the image based on the 'valid' pixels\n",
    "    new_image = new_image.crop((0, 0, original_size[0], original_size[1]))\n",
    "\n",
    "    return new_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_image2 = merge2(img1, img2)\n",
    "# merged_image2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "unmerged_image2 = unmerge2(merged_image2)\n",
    "# unmerged_image2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ImageOps.equalize(ImageChops.subtract(img1, merged_image2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ImageOps.equalize(ImageChops.subtract(img2, unmerged_image2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "from PIL import Image\n",
    "from typing import Union, IO\n",
    "\n",
    "def hide(input_image: Union[str, IO[bytes]],\n",
    "        message: str,\n",
    "        encoding: str = 'UTF-8',\n",
    "        auto_convert_rgb: bool = False):\n",
    "    \"\"\"Hide a message (string) in an image with the\n",
    "    LSB (Least Significant Bit) technique.\n",
    "    \"\"\"\n",
    "    message_length = len(message)\n",
    "    assert message_length != 0, \"message length is zero\"\n",
    "\n",
    "    img = Image.open(input_image)\n",
    "\n",
    "    if img.mode not in ['RGB', 'RGBA']:\n",
    "        if not auto_convert_rgb:\n",
    "            print('The mode of the image is not RGB. Mode is {}'.\\\n",
    "                                                            format(img.mode))\n",
    "            answer = input('Convert the image to RGB ? [Y / n]\\n') or 'Y'\n",
    "            if answer.lower() == 'n':\n",
    "                raise Exception('Not a RGB image.')\n",
    "        img = img.convert('RGB')\n",
    "\n",
    "    encoded = img.copy()\n",
    "    width, height = img.size\n",
    "    index = 0\n",
    "\n",
    "    message = str(message_length) + \":\" + str(message)\n",
    "    message_bits = \"\".join(a2bits_list(message, encoding))\n",
    "    message_bits += '0' * ((3 - (len(message_bits) % 3)) % 3)\n",
    "\n",
    "    npixels = width * height\n",
    "    len_message_bits = len(message_bits)\n",
    "    if len_message_bits > npixels * 3:\n",
    "        raise Exception(\"The message you want to hide is too long: {}\". \\\n",
    "                                                        format(message_length))\n",
    "    for row in range(height):\n",
    "        for col in range(width):\n",
    "            if index + 3 <= len_message_bits :\n",
    "\n",
    "                # Get the colour component.\n",
    "                pixel = img.getpixel((col, row))\n",
    "                r = pixel[0]\n",
    "                g = pixel[1]\n",
    "                b = pixel[2]\n",
    "\n",
    "                # Change the Least Significant Bit of each colour component.\n",
    "                r = setlsb(r, message_bits[index])\n",
    "                g = setlsb(g, message_bits[index+1])\n",
    "                b = setlsb(b, message_bits[index+2])\n",
    "\n",
    "                # Save the new pixel\n",
    "                if img.mode == 'RGBA':\n",
    "                    encoded.putpixel((col, row), (r, g, b, pixel[3]))\n",
    "                else:\n",
    "                    encoded.putpixel((col, row), (r, g, b))\n",
    "\n",
    "                index += 3\n",
    "            else:\n",
    "                img.close()\n",
    "                return encoded\n",
    "\n",
    "\n",
    "def reveal(input_image: Union[str, IO[bytes]], encoding='UTF-8'):\n",
    "    \"\"\"Find a message in an image (with the LSB technique).\n",
    "    \"\"\"\n",
    "    img = Image.open(input_image)\n",
    "    width, height = img.size\n",
    "    buff, count = 0, 0\n",
    "    bitab = []\n",
    "    limit = None\n",
    "    for row in range(height):\n",
    "        for col in range(width):\n",
    "\n",
    "            # pixel = [r, g, b] or [r,g,b,a]\n",
    "            pixel = img.getpixel((col, row))\n",
    "            if img.mode == 'RGBA':\n",
    "                pixel = pixel[:3] # ignore the alpha\n",
    "            for color in pixel:\n",
    "                buff += (color&1)<<(ENCODINGS[encoding]-1 - count)\n",
    "                count += 1\n",
    "                if count == ENCODINGS[encoding]:\n",
    "                    bitab.append(chr(buff))\n",
    "                    buff, count = 0, 0\n",
    "                    if bitab[-1] == \":\" and limit == None:\n",
    "                        try:\n",
    "                            limit = int(\"\".join(bitab[:-1]))\n",
    "                        except:\n",
    "                            pass\n",
    "\n",
    "            if len(bitab)-len(str(limit))-1 == limit :\n",
    "                img.close()\n",
    "                return \"\".join(bitab)[len(str(limit))+1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import base64\n",
    "import itertools\n",
    "from typing import List, Iterator, Tuple, Union\n",
    "from functools import reduce\n",
    "\n",
    "ENCODINGS = {\n",
    "    'UTF-8': 8,\n",
    "    'UTF-32LE': 32\n",
    "}\n",
    "\n",
    "def a2bits(chars: str) -> str:\n",
    "    \"\"\"Converts a string to its bits representation as a string of 0's and 1's.\n",
    "    >>> a2bits(\"Hello World!\")\n",
    "    '010010000110010101101100011011000110111100100000010101110110111101110010011011000110010000100001'\n",
    "    \"\"\"\n",
    "    return bin(reduce(lambda x, y : (x<<8)+y, (ord(c) for c in chars), 1))[3:]\n",
    "\n",
    "def a2bits_list(chars):\n",
    "    \"\"\"Convert a string to its bits representation as a list of 0's and 1's.\n",
    "    >>>  a2bits_list(\"Hello World!\")\n",
    "    ['01001000',\n",
    "    '01100101',\n",
    "    '01101100',\n",
    "    '01101100',\n",
    "    '01101111',\n",
    "    '00100000',\n",
    "    '01010111',\n",
    "    '01101111',\n",
    "    '01110010',\n",
    "    '01101100',\n",
    "    '01100100',\n",
    "    '00100001']\n",
    "    >>> \"\".join(a2bits_list(\"Hello World!\"))\n",
    "    '010010000110010101101100011011000110111100100000010101110110111101110010011011000110010000100001'\n",
    "    \"\"\"\n",
    "    return [bin(ord(x))[2:].rjust(8,\"0\") for x in chars]\n",
    "\n",
    "def bs(s: int) -> str:\n",
    "    \"\"\"Converts an int to its bits representation as a string of 0's and 1's.\n",
    "    \"\"\"\n",
    "    return str(s) if s<=1 else bs(s>>1) + str(s&1)\n",
    "\n",
    "def setlsb(component: int, bit: str) -> int:\n",
    "    \"\"\"Set Least Significant Bit of a colour component.\n",
    "    \"\"\"\n",
    "    return component & ~1 | int(bit)\n",
    "\n",
    "def n_at_a_time(items: List[int], n: int, fillvalue: str) \\\n",
    "        -> Iterator[Tuple[Union[int, str]]]:\n",
    "    \"\"\"Returns an iterator which groups n items at a time.\n",
    "    Any final partial tuple will be padded with the fillvalue\n",
    "    >>> list(n_at_a_time([1, 2, 3, 4, 5], 2, 'X'))\n",
    "    [(1, 2), (3, 4), (5, 'X')]\n",
    "    \"\"\"\n",
    "    it = iter(items)\n",
    "    return itertools.zip_longest(*[it] * n, fillvalue=fillvalue)\n",
    "\n",
    "def binary2base64(binary_file: str) -> str:\n",
    "    \"\"\"Convert a binary file (OGG, executable, etc.) to a\n",
    "    printable string.\n",
    "    \"\"\"\n",
    "    # Use mode = \"rb\" to read binary file\n",
    "    with open(binary_file, \"rb\") as bin_file:\n",
    "        encoded_string = base64.b64encode(bin_file.read())\n",
    "    return encoded_string.decode()\n",
    "\n",
    "def base642binary(b64_fname: str) -> bytes:\n",
    "    \"\"\"Convert a printable string to a binary file.\n",
    "    \"\"\"\n",
    "    b64_fname += '==='\n",
    "    return base64.b64decode(b64_fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"We're no strangers to love\\nYou know the rules and so do I\\nA full commitment's what I'm thinking of\\nYou wouldn't get this from any other guy\\n\\nI just wanna tell you how I'm feeling\\nGotta make you understand\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\n\\nWe've known each other for so long\\nYour heart's been aching but you're too shy to say it\\nInside we both know what's been going on\\nWe know the game and we're gonna play it\\n\\nAnd if you ask me how I'm feeling\\nDon't tell me you're too blind to see\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\n\\nNever gonna give, never gonna give\\n(Give you up)\\n(Ooh) Never gonna give, never gonna give\\n(Give you up)\\n\\nWe've known each other for so long\\nYour heart's been aching but you're too shy to say it\\nInside we both know what's been going on\\nWe know the game and we're gonna play it\\n\\nI just wanna tell you how I'm feeling\\nGotta make you understand\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('text.txt', 'r') as myfile:\n",
    "    text = myfile.read()\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hide(input_image, text):\n",
    "    '''\n",
    "    Hide a message (string) in an image with the\n",
    "    LSB (Least Significant Bit) technique.\n",
    "    INPUT: path to an RGB image, path to text file\n",
    "    OUTPUT: new image with text encoded in the image\n",
    "    '''\n",
    "    with open(text, 'r') as myfile:\n",
    "        message = myfile.read()\n",
    "    \n",
    "    message_length = len(message)\n",
    "\n",
    "    img = Image.open(input_image)\n",
    "\n",
    "    new_image = img.copy()\n",
    "    width, height = img.size\n",
    "    index = 0\n",
    "    \n",
    "    message = str(message_length) + ':' + str(message)\n",
    "    message_bits = \"\".join(a2bits_list(message))\n",
    "    # ensure message_bits is a multiple of 3, for each color channel\n",
    "    message_bits += '0' * ((3 - (len(message_bits) % 3)) % 3)\n",
    "\n",
    "    npixels = width * height\n",
    "    len_message_bits = len(message_bits)\n",
    "    if len_message_bits > npixels * 3:\n",
    "        raise Exception('The message you want to hide is too long: {}'. \\\n",
    "                                                        format(message_length))\n",
    "    for row in range(height):\n",
    "        for col in range(width):\n",
    "            if index + 3 <= len_message_bits :\n",
    "\n",
    "                # Get the colour component.\n",
    "                pixel = img.getpixel((col, row))\n",
    "                r = pixel[0]\n",
    "                g = pixel[1]\n",
    "                b = pixel[2]\n",
    "\n",
    "                # Change the Least Significant Bit of each colour component.\n",
    "                r = setlsb(r, message_bits[index])\n",
    "                g = setlsb(g, message_bits[index + 1])\n",
    "                b = setlsb(b, message_bits[index + 2])\n",
    "\n",
    "                # Save the new pixel\n",
    "                new_image.putpixel((col, row), (r, g, b))\n",
    "\n",
    "                index += 3\n",
    "            else:\n",
    "                img.close()\n",
    "                return new_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reveal(input_image):\n",
    "    '''\n",
    "    Find a message in an image (with the LSB technique).\n",
    "    INPUT: path to an RGB image\n",
    "    OUTPUT: decoded text\n",
    "    '''\n",
    "    img = Image.open(input_image)\n",
    "    width, height = img.size\n",
    "    buff, count = 0, 0\n",
    "    bitab = []\n",
    "    limit = None\n",
    "    for row in range(height):\n",
    "        for col in range(width):\n",
    "\n",
    "            pixel = img.getpixel((col, row))\n",
    "            for color in pixel:\n",
    "                # 8 for UTF-8\n",
    "                buff += (color & 1) << (8 - 1 - count)\n",
    "                count += 1\n",
    "                if count == 8:\n",
    "                    bitab.append(chr(buff))\n",
    "                    buff, count = 0, 0\n",
    "                    if bitab[-1] == ':' and limit == None:\n",
    "                        try:\n",
    "                            limit = int(''.join(bitab[: -1]))\n",
    "                        except:\n",
    "                            pass\n",
    "\n",
    "            if len(bitab) - len(str(limit)) - 1 == limit:\n",
    "                img.close()\n",
    "                return ''.join(bitab)[len(str(limit)) + 1 :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def a2bits_list(chars):\n",
    "    '''\n",
    "    Convert a string (UTF-8) to its bits representation as a list of 0's and 1's.\n",
    "    >>>  a2bits_list(\"Hello World!\")\n",
    "    ['01001000',\n",
    "    '01100101',\n",
    "    '01101100',\n",
    "    '01101100',\n",
    "    '01101111',\n",
    "    '00100000',\n",
    "    '01010111',\n",
    "    '01101111',\n",
    "    '01110010',\n",
    "    '01101100',\n",
    "    '01100100',\n",
    "    '00100001']\n",
    "    >>> \"\".join(a2bits_list(\"Hello World!\"))\n",
    "    '010010000110010101101100011011000110111100100000010101110110111101110010011011000110010000100001'\n",
    "    INPUT: string of text\n",
    "    OUTPUT: string of 0's and 1's\n",
    "    '''\n",
    "    return [bin(ord(x))[2:].rjust(8, '0') for x in chars]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setlsb(component, bit):\n",
    "    '''\n",
    "    Set Least Significant Bit of a colour component.\n",
    "    INPUT: r, g, or b value from 0-255, bit to encode\n",
    "    OUTPUT: new r, g, or b value with encoded bit\n",
    "    '''\n",
    "    return component & ~1 | int(bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden = hide('forest.jpg', 'text.txt')#*1589)\n",
    "hidden.save('hidden.bmp')\n",
    "# hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"We're no strangers to love\\nYou know the rules and so do I\\nA full commitment's what I'm thinking of\\nYou wouldn't get this from any other guy\\n\\nI just wanna tell you how I'm feeling\\nGotta make you understand\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\n\\nWe've known each other for so long\\nYour heart's been aching but you're too shy to say it\\nInside we both know what's been going on\\nWe know the game and we're gonna play it\\n\\nAnd if you ask me how I'm feeling\\nDon't tell me you're too blind to see\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\n\\nNever gonna give, never gonna give\\n(Give you up)\\n(Ooh) Never gonna give, never gonna give\\n(Give you up)\\n\\nWe've known each other for so long\\nYour heart's been aching but you're too shy to say it\\nInside we both know what's been going on\\nWe know the game and we're gonna play it\\n\\nI just wanna tell you how I'm feeling\\nGotta make you understand\\n\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\\nNever gonna say goodbye\\nNever gonna tell a lie and hurt you\\nNever gonna give you up\\nNever gonna let you down\\nNever gonna run around and desert you\\nNever gonna make you cry\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reveal('hidden.bmp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff = ImageOps.equalize(ImageChops.subtract(hidden, img1))\n",
    "# diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# diff.crop((0, 0, 100, 100)).resize((1000, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('WarAndPeace.txt', 'r') as myfile:\n",
    "#     warandpeace = myfile.read()\n",
    "# warandpeace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stbasils = Image.open('StBasils.jpg').resize((9000, 9000))\n",
    "# stbasils.save('StBasilsLg.jpg')\n",
    "# stbasils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hidden = hide('StBasilsLg.jpg', 'WarAndPeace.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hidden.save('hidden.bmp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reveal('hidden.bmp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# diff = ImageOps.equalize(ImageChops.subtract(hidden, stbasils))\n",
    "# diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encrypt(image_path, text_path):\n",
    "    '''\n",
    "    Encrypt a string inside an image using the least significant bits method\n",
    "    INPUT: string, a path to an image file; string, a path to a text file\n",
    "    OUTPUT: a bitmap image saved in the root folder with _hidden.bmp appended to the filename\n",
    "    '''\n",
    "    \n",
    "    # check if image is already a bitmap\n",
    "    if image_path[-4:] != '.bmp':\n",
    "        img = Image.open(image_path)\n",
    "        image_path = image_path[:-4] + '.bmp'\n",
    "        img.save(image_path)\n",
    "\n",
    "    with open(image_path[:-4] + '.bmp','rb') as bmp_file:\n",
    "        bmp = bmp_file.read()\n",
    "    \n",
    "    with open(text_path,'rb') as to_hide_file:\n",
    "        msg = to_hide_file.read()\n",
    "        \n",
    "    # append the length of the message to the message itself to assist with decoding\n",
    "    temp = msg.decode('utf-8')\n",
    "    msg = bytearray(str(len(temp)) + '\\n' + temp, 'utf-8')\n",
    "\n",
    "    # color data begins at the byte at position 10\n",
    "    start_offset = bmp[10]\n",
    "\n",
    "    bmpa = bytearray(bmp)\n",
    "    \n",
    "    # convert the msg in bytes to bits\n",
    "    bits = []\n",
    "    for i in range(len(msg)):\n",
    "        # a byte can at max be 8 digits long, i.e. 0b11111111 = 255\n",
    "        # we start at the left most bit (position 7) and work down to 0\n",
    "        for j in range(7,-1,-1):\n",
    "            #Create the logic array of bits for our data\n",
    "            bits.append(nth_bit_present(msg[i],j))\n",
    "\n",
    "    data_array = bits\n",
    "\n",
    "    # ensure the image is large enough to contain the text\n",
    "    assert len(data_array) < len(bmpa) + start_offset\n",
    "\n",
    "    for i in range(len(data_array)):\n",
    "        bmpa[i + start_offset] = set_final_bit(bmpa[i + start_offset],data_array[i])\n",
    "\n",
    "    with open(image_path.replace('.bmp','_hidden.bmp'),'wb') as out:\n",
    "        out.write(bmpa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def hide_data(bmp, msg, image_path):\n",
    "#     # the byte at position 10 tells us where the color data starts\n",
    "#     start_offset = bmp[10]\n",
    "\n",
    "#     bmpa = bytearray(bmp)\n",
    "#     data_array = data_to_bits(msg)\n",
    "\n",
    "#     #We need to make sure there is enough space to hide our data\n",
    "#     assert len(data_array) < len(bmpa) + start_offset\n",
    "\n",
    "#     for i in range(len(data_array)):\n",
    "#         bmpa[i + start_offset] = set_final_bit(bmpa[i + start_offset],data_array[i])\n",
    "\n",
    "#     with open(image_path.replace('.bmp','_hidden.bmp'),'wb') as out:\n",
    "#         out.write(bmpa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def write_hidden_bmp(bytes_to_write, image_path):\n",
    "#     with open(image_path.replace('.bmp','_hidden.bmp'),'wb') as out:\n",
    "#         out.write(bytes_to_write)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def data_to_bits(data):\n",
    "#     bits = []\n",
    "#     for i in range(len(data)):\n",
    "#         #A byte can at max be 8 digits long, i.e. 0b11111111 = 255\n",
    "#         #We start at the left most bit (position 7) and work down to 0\n",
    "#         for j in range(7,-1,-1):\n",
    "#             #Create the logic array of bits for our data\n",
    "#             bits.append(nth_bit_present(data[i],j))\n",
    "\n",
    "#     return bits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nth_bit_present(my_byte,n):\n",
    "    # bitwise check to see what the nth bit is\n",
    "    # if anything other than 0, it is TRUE else FALSE\n",
    "    return (my_byte & (1 << n)) != 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_final_bit(my_byte,ends_in_one):\n",
    "    new_byte = 0\n",
    "    if ends_in_one:\n",
    "        if(nth_bit_present(my_byte,0)):\n",
    "            new_byte = my_byte #No modification needed, it already ends in one\n",
    "        else:\n",
    "            new_byte = my_byte + 1\n",
    "    else:\n",
    "        if(nth_bit_present(my_byte,0)):\n",
    "            new_byte = my_byte - 1\n",
    "        else:\n",
    "            new_byte = my_byte #No modification needed, it already ends in zero\n",
    "    return new_byte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_image = encrypt('forest.jpg', 'text.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decrypt(image_path):\n",
    "    with open(image_path,'rb') as bmp_file:\n",
    "        bmp = bmp_file.read()\n",
    "\n",
    "    start_offset = bmp[10] #The byte at position 10 tells us where the color data starts\n",
    "\n",
    "    #Deconstruct each byte and get its final bit\n",
    "    bits = []\n",
    "    for i in range(start_offset, len(bmp)):\n",
    "        bits.append(nth_bit_present(bmp[i], 0))\n",
    "\n",
    "    #Combine our bit array into bytes\n",
    "    out_bytes = []\n",
    "    for i in range(0, len(bits), 8): #Take each 8-bit chunk\n",
    "        if(len(bits) - i > 8):\n",
    "            out_bytes.append(bits_to_byte(bits[i: i + 8]))\n",
    "\n",
    "    #Convert bytes to characters\n",
    "    out = []\n",
    "    for b in out_bytes:\n",
    "        out.append(chr(b))\n",
    "\n",
    "    output = ''.join(out)\n",
    "    \n",
    "    idx = output.find('\\n')\n",
    "    msg_len = int(output[:idx])\n",
    "    \n",
    "    msg = output[idx + 1: idx + msg_len + 1]\n",
    "    \n",
    "    with open(\"hidden_message.txt\", \"w\") as text_file:\n",
    "        text_file.write(msg)\n",
    "    \n",
    "    print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bits_to_byte(bits):\n",
    "    # convert 8 bits into 1 byte\n",
    "    assert len(bits) == 8\n",
    "    new_byte = 0\n",
    "    for i in range(8):\n",
    "        if bits[i]==True:\n",
    "            #This bit==1 and the \"position\" we are at in the byte is 7-i\n",
    "            #Bitwise OR will insert a 1 a this position\n",
    "            new_byte |= 1 << 7 - i\n",
    "        else:\n",
    "            #This bit==0 and the \"position\" we are at in the byte is 7-i\n",
    "            #Bitwise OR will insert a 0 a this position\n",
    "            new_byte |= 0 << 7 - i\n",
    "    return new_byte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're no strangers to love\n",
      "You know the rules and so do I\n",
      "A full commitment's what I'm thinking of\n",
      "You wouldn't get this from any other guy\n",
      "\n",
      "I just wanna tell you how I'm feeling\n",
      "Gotta make you understand\n",
      "\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n",
      "Never gonna say goodbye\n",
      "Never gonna tell a lie and hurt you\n",
      "\n",
      "We've known each other for so long\n",
      "Your heart's been aching but you're too shy to say it\n",
      "Inside we both know what's been going on\n",
      "We know the game and we're gonna play it\n",
      "\n",
      "And if you ask me how I'm feeling\n",
      "Don't tell me you're too blind to see\n",
      "\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n",
      "Never gonna say goodbye\n",
      "Never gonna tell a lie and hurt you\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n",
      "Never gonna say goodbye\n",
      "Never gonna tell a lie and hurt you\n",
      "\n",
      "Never gonna give, never gonna give\n",
      "(Give you up)\n",
      "(Ooh) Never gonna give, never gonna give\n",
      "(Give you up)\n",
      "\n",
      "We've known each other for so long\n",
      "Your heart's been aching but you're too shy to say it\n",
      "Inside we both know what's been going on\n",
      "We know the game and we're gonna play it\n",
      "\n",
      "I just wanna tell you how I'm feeling\n",
      "Gotta make you understand\n",
      "\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n",
      "Never gonna say goodbye\n",
      "Never gonna tell a lie and hurt you\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n",
      "Never gonna say goodbye\n",
      "Never gonna tell a lie and hurt you\n",
      "Never gonna give you up\n",
      "Never gonna let you down\n",
      "Never gonna run around and desert you\n",
      "Never gonna make you cry\n"
     ]
    }
   ],
   "source": [
    "decrypt('forest_hidden.bmp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(240, 64, 64)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11110000', '01000000', '01000000')) # salmon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('11110000', '01111000', '00010100')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integer_to_binary((240, 120, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(241, 121, 21)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11110001', '01111001', '00010101'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(242, 122, 22)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11110010', '01111010', '00010110'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(244, 124, 16)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11110100', '01111100', '00010000'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(248, 112, 28)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11111000', '01110000', '00011100'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(224, 104, 4)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11100000', '01101000', '00000100'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(208, 88, 52)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('11010000', '01011000', '00110100'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(176, 56, 84)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('10110000', '00111000', '01010100'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112, 248, 148)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_to_integer(('01110000', '11111000', '10010100'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage import io\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1271f36a0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Orange palate\n",
    "color = np.array([[240,   120,   20],\n",
    "                  [241,   121,   21],\n",
    "                  [242,   122,   22],\n",
    "                  [244,   124,   16],\n",
    "                  [248,   112,   28],\n",
    "                  [224,   104,   4],\n",
    "                  [208,   88,    52],\n",
    "                  [176,   56,    84],\n",
    "                  [112,   248,   148]\n",
    "                 ], dtype=np.uint8)\n",
    "indices = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[240  64  64]\n",
      " [241  65  65]\n",
      " [243  67  67]\n",
      " [247  71  71]\n",
      " [255  79  79]\n",
      " [239  95  95]\n",
      " [207 127 127]\n",
      " [143  63  63]\n",
      " [ 15 191 191]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZgAAAC8CAYAAAD1qMtDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAABiZJREFUeJzt2sFtwkAURdEYsfCSEigFOqM0l5ISSAVDBZGSK0UT7HMqeLuR7p9ljPEBAAAAAAC/dZo9AAAAAACA9yQwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAcp494Dtf9/uYvYF9W5Zl9gQO4HRyx+Pvnc//9jlnR9Z1nT2BnXteLrMncACf1+vsCRzAtm2zJ3AAj8dj9gQO4Hm7/SieKR8AAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJMsYY/YGAAAAAADekB/MAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEAiMAMAAAAAkAjMAAAAAAAkAjMAAAAAAInADAAAAABAIjADAAAAAJAIzAAAAAAAJAIzAAAAAACJwAwAAAAAQCIwAwAAAACQCMwAAAAAACQCMwAAAAAAicAMAAAAAEDyAtDTEXOTQDi8AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1272bd240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Salmon palate\n",
    "val0 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val1 = binary_to_integer(('11110001', '01000001', '01000001'))\n",
    "val2 = binary_to_integer(('11110011', '01000011', '01000011'))\n",
    "val3 = binary_to_integer(('11110111', '01000111', '01000111'))\n",
    "val4 = binary_to_integer(('11111111', '01001111', '01001111'))\n",
    "val5 = binary_to_integer(('11101111', '01011111', '01011111'))\n",
    "val6 = binary_to_integer(('11001111', '01111111', '01111111'))\n",
    "val7 = binary_to_integer(('10001111', '00111111', '00111111'))\n",
    "val8 = binary_to_integer(('00001111', '10111111', '10111111'))\n",
    "\n",
    "color = np.array([[val0[0], val0[1], val0[2]],\n",
    "                  [val1[0], val1[1], val1[2]],\n",
    "                  [val2[0], val2[1], val2[2]],\n",
    "                  [val3[0], val3[1], val3[2]],\n",
    "                  [val4[0], val4[1], val4[2]],\n",
    "                  [val5[0], val5[1], val5[2]],\n",
    "                  [val6[0], val6[1], val6[2]],\n",
    "                  [val7[0], val7[1], val7[2]],\n",
    "                  [val8[0], val8[1], val8[2]]\n",
    "                 ], dtype=np.uint8)\n",
    "print(color)\n",
    "indices = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[240  64  64]\n",
      " [240  64  64]\n",
      " [240  64  64]\n",
      " [240  64  64]\n",
      " [240  64  64]\n",
      " [224  80  80]\n",
      " [192 112 112]\n",
      " [128  48  48]\n",
      " [  0 176 176]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1273c6898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Salmon palate, LSB set to 0's\n",
    "val0 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val1 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val2 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val3 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val4 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val5 = binary_to_integer(('11100000', '01010000', '01010000'))\n",
    "val6 = binary_to_integer(('11000000', '01110000', '01110000'))\n",
    "val7 = binary_to_integer(('10000000', '00110000', '00110000'))\n",
    "val8 = binary_to_integer(('00000000', '10110000', '10110000'))\n",
    "\n",
    "color = np.array([[val0[0], val0[1], val0[2]],\n",
    "                  [val1[0], val1[1], val1[2]],\n",
    "                  [val2[0], val2[1], val2[2]],\n",
    "                  [val3[0], val3[1], val3[2]],\n",
    "                  [val4[0], val4[1], val4[2]],\n",
    "                  [val5[0], val5[1], val5[2]],\n",
    "                  [val6[0], val6[1], val6[2]],\n",
    "                  [val7[0], val7[1], val7[2]],\n",
    "                  [val8[0], val8[1], val8[2]]\n",
    "                 ], dtype=np.uint8)\n",
    "print(color)\n",
    "indices = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[240  64  64]\n",
      " [247  79  73]\n",
      " [112 248 148]\n",
      " [112 240 144]\n",
      " [240  64  64]\n",
      " [224  80  80]\n",
      " [192 112 112]\n",
      " [128  48  48]\n",
      " [  0 176 176]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1272090b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Salmon, salmon with green inserted, green, green decoded\n",
    "val0 = binary_to_integer(('11110000', '01000000', '01000000')) # salmon\n",
    "val1 = binary_to_integer(('11110111', '01001111', '01001001')) # salmon with green inserted\n",
    "val2 = binary_to_integer(('01110000', '11111000', '10010100')) # green\n",
    "val3 = binary_to_integer(('01110000', '11110000', '10010000')) # green decoded\n",
    "\n",
    "\n",
    "val5 = binary_to_integer(('11100000', '01010000', '01010000'))\n",
    "val6 = binary_to_integer(('11000000', '01110000', '01110000'))\n",
    "val7 = binary_to_integer(('10000000', '00110000', '00110000'))\n",
    "val8 = binary_to_integer(('00000000', '10110000', '10110000'))\n",
    "\n",
    "color = np.array([[val0[0], val0[1], val0[2]],\n",
    "                  [val1[0], val1[1], val1[2]],\n",
    "                  [val2[0], val2[1], val2[2]],\n",
    "                  [val3[0], val3[1], val3[2]],\n",
    "                  [val4[0], val4[1], val4[2]],\n",
    "                  [val5[0], val5[1], val5[2]],\n",
    "                  [val6[0], val6[1], val6[2]],\n",
    "                  [val7[0], val7[1], val7[2]],\n",
    "                  [val8[0], val8[1], val8[2]]\n",
    "                 ], dtype=np.uint8)\n",
    "print(color)\n",
    "indices = [[0, 1, 2, 3]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 1 0 3 4 2]\n",
      " [4 5 0 0 3 1]\n",
      " [3 2 1 2 5 5]\n",
      " [5 3 5 3 3 4]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x12790a198>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x12722e828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "palette = np.array([[255,   0,   0], # index 0: red\n",
    "                    [  0, 255,   0], # index 1: green\n",
    "                    [  0,   0, 255], # index 2: blue\n",
    "                    [255, 255, 255], # index 3: white\n",
    "                    [  0,   0,   0], # index 4: black\n",
    "                    [255, 255,   0], # index 5: yellow\n",
    "                    ], dtype=np.uint8)\n",
    "m, n = 4, 6\n",
    "indices = np.random.randint(0, len(palette), size=(m, n))\n",
    "print(indices)\n",
    "io.imshow(palette[[indices]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[240  64  64]\n",
      " [241  65  65]\n",
      " [242  66  66]\n",
      " [244  68  68]\n",
      " [248  72  72]\n",
      " [224  80  80]\n",
      " [208  96  96]\n",
      " [176   0   0]\n",
      " [112 192 192]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/io/_plugins/matplotlib_plugin.py:51: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  out_of_range_float = (np.issubdtype(image.dtype, np.float) and\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1279485c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x127a34ef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Salmon palate, cumulative bits changed\n",
    "val0 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val1 = binary_to_integer(('11110001', '01000001', '01000001'))\n",
    "val2 = binary_to_integer(('11110010', '01000010', '01000010'))\n",
    "val3 = binary_to_integer(('11110100', '01000100', '01000100'))\n",
    "val4 = binary_to_integer(('11111000', '01001000', '01001000'))\n",
    "val5 = binary_to_integer(('11100000', '01010000', '01010000'))\n",
    "val6 = binary_to_integer(('11010000', '01100000', '01100000'))\n",
    "val7 = binary_to_integer(('10110000', '00000000', '00000000'))\n",
    "val8 = binary_to_integer(('01110000', '11000000', '11000000'))\n",
    "\n",
    "color = np.array([[val0[0], val0[1], val0[2]],\n",
    "                  [val1[0], val1[1], val1[2]],\n",
    "                  [val2[0], val2[1], val2[2]],\n",
    "                  [val3[0], val3[1], val3[2]],\n",
    "                  [val4[0], val4[1], val4[2]],\n",
    "                  [val5[0], val5[1], val5[2]],\n",
    "                  [val6[0], val6[1], val6[2]],\n",
    "                  [val7[0], val7[1], val7[2]],\n",
    "                  [val8[0], val8[1], val8[2]]\n",
    "                 ], dtype=np.uint8)\n",
    "print(color)\n",
    "indices = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Salmon palate, one bit at a time changed\n",
    "val0 = binary_to_integer(('11110000', '01000000', '01000000'))\n",
    "val1 = binary_to_integer(('11110001', '01000001', '01000001'))\n",
    "val2 = binary_to_integer(('11110011', '01000011', '01000011'))\n",
    "val3 = binary_to_integer(('11110111', '01000111', '01000111'))\n",
    "val4 = binary_to_integer(('11111111', '01001111', '01001111'))\n",
    "val5 = binary_to_integer(('11101111', '01011111', '01011111'))\n",
    "val6 = binary_to_integer(('11001111', '01111111', '01111111'))\n",
    "val7 = binary_to_integer(('10001111', '00111111', '00111111'))\n",
    "val8 = binary_to_integer(('00001111', '10111111', '10111111'))\n",
    "\n",
    "color = np.array([[val0[0], val0[1], val0[2]],\n",
    "                  [val1[0], val1[1], val1[2]],\n",
    "                  [val2[0], val2[1], val2[2]],\n",
    "                  [val3[0], val3[1], val3[2]],\n",
    "                  [val4[0], val4[1], val4[2]],\n",
    "                  [val5[0], val5[1], val5[2]],\n",
    "                  [val6[0], val6[1], val6[2]],\n",
    "                  [val7[0], val7[1], val7[2]],\n",
    "                  [val8[0], val8[1], val8[2]]\n",
    "                 ], dtype=np.uint8)\n",
    "indices = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
    "plt.figure(figsize=(20, 30))\n",
    "plt.axis('off')\n",
    "io.imshow(color[[indices]])\n",
    "plt.show()"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}