static_as_png.ipynb

{
 "cells":[
  {
   "cell_type":"markdown",
   "source":[
    "# Static as PNG\n",
    "\n",
    "**Intent**\n",
    "\n",
    "The image of an old black-and-white TV in horror films is ubiquitous.\n",
    "This project aims to create digital snapshots of that experience both in black-and-white as well as in color. \n",
    "\n",
    "# Color Space\n",
    "\n",
    "The color space computers generally use is [RGB](https:\/\/en.wikipedia.org\/wiki\/RGB).\n",
    "RGB is a digital color space.\n",
    "It has three discrete channels all of which are represented as integers ([0, 255]).\n",
    "\n",
    "The color space old TVs used in the US was [NTSC](https:\/\/en.wikipedia.org\/wiki\/NTSC) (A.K.A. [YIQ](https:\/\/en.wikipedia.org\/wiki\/YIQ)).\n",
    "YIQ is _not_ a digital color space.\n",
    "It was _meant_ for analog.\n",
    "This means there are going to be issues that crop up.\n",
    "Some of those differences are presented below.\n",
    "\n",
    "## Questions\n",
    "\n",
    "1. Is the built-in color conversion reversible or near reversible?\n",
    "2. Is the custom color conversion reversible or near reversible?\n",
    "3. What part of the YIQ color space is not addressable as RGB"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"hWqspnjonuQNG9ZUXQSohk",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q1 - Pseudocode\n",
    "\n",
    "1. Start with the digital RGB space (256 x 256 x 256)\n",
    "2. Convert to analog YIQ space\n",
    "3. Calculate the YIQ range\n",
    "4. Reverse the YIQ range to RGB to check for (near)reversibility"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"PxPTpcKkVzwPhBUjMtWABk",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "import colorsys as cs\n",
    "\n",
    "y_rng = [float('inf'), float('-inf')]\n",
    "i_rng = [float('inf'), float('-inf')]\n",
    "q_rng = [float('inf'), float('-inf')]\n",
    "tot = 256 * 256 * 256\n",
    "r1 = tot\n",
    "r2 = tot\n",
    "lim = 1\/256\n",
    "\n",
    "for r in range(256):\n",
    "    for g in range(256):\n",
    "        for b in range(256):\n",
    "            (r_in, g_in, b_in) = (r\/255, g\/255, b\/255)\n",
    "            (y, i, q) = cs.rgb_to_yiq(r_in, g_in, b_in)\n",
    "            (r_out, g_out, b_out) = cs.yiq_to_rgb(y, i, q)\n",
    "            y_rng = (min(y_rng[0], y), max(y_rng[1], y))\n",
    "            i_rng = (min(i_rng[0], i), max(i_rng[1], i))\n",
    "            q_rng = (min(q_rng[0], q), max(q_rng[1], q))\n",
    "            if not all([r_in == r_out, g_in == g_out, b_in == b_out]):\n",
    "                r1 -= 1\n",
    "            if not all([abs(r_in - r_out) <= lim, abs(g_in - g_out) <= lim, (b_in - b_out) <= lim]):\n",
    "                r2 -= 1\n",
    "\n",
    "print('--- using built-in color conversion ---')\n",
    "print(f'Y: [{y_rng[0]}, {y_rng[1]}]')\n",
    "print(f'I: [{i_rng[0]}, {i_rng[1]}]')\n",
    "print(f'Q: [{q_rng[0]}, {q_rng[1]}]')\n",
    "print(f'{100 * r1 \/ tot} % of the space is perfectly reversible ({r1}\/{tot})')\n",
    "print(f'{100 * r2 \/ tot} % of the space is near perfectly (diff <= {lim}) reversible ({r2}\/{tot})')\n",
    "\n",
    "del y_rng, i_rng, q_rng, tot, r1, r2, lim, r_in, g_in, b_in, r, g, b, y, i, q, r_out, g_out, b_out"
   ],
   "execution_count":1,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"zJfSypNKnNiAhyvkMXvx1Y",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q1 - Results\n",
    "\n",
    "Using the built-in color space conversion:\n",
    "\n",
    "* The RGB space must be [0, 1] for `colorsys.yiq_to_rgb()` to even make sense\n",
    "* The RGB space [0, 1] x [0, 1] x [0, 1] converts to the YIQ space [0.0, 1.0] x [-0.599, 0.599] x [-0.5251, 0.5251]\n",
    "* 12.99 % of the space is perfectly reversible\n",
    "* 100 % of the space is near perfectly (difference <= 1\/256) reversible"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"Vaf2qZGGtfY8UGd7EcqphS",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Custom Color Space Functions\n",
    "\n",
    "There is a built-in color package (`colorsys`) in Python.\n",
    "There is a built-in image package (`PIL`) in Python.\n",
    "Pixel values in `PIL` work in the range [0, 255]. \n",
    "`colorsys` does not allow for rgb => yiq => rgb in `PIL`'s range.\n",
    "\n",
    "The math used in `rgb_to_yiq` and `yiq_to_rgb` are based on the formulas found [here](https:\/\/en.wikipedia.org\/wiki\/YIQ).\n",
    "\n",
    "**NOTE**: The [clamp](https:\/\/en.wikipedia.org\/wiki\/Clamping_(graphics)) in `yiq_to_rgb` this is defined in the [standard](https:\/\/en.wikipedia.org\/wiki\/YUV)."
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"SOZFMdOg3ytZ4XeNxLI6sH",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "import typing as t\n",
    "\n",
    "def rgb_to_yiq(rgb: t.Tuple[int, int, int]) -> t.Tuple[float, float, float]:\n",
    "    y = 0.2990 * rgb[0] + 0.5870 * rgb[1] + 0.1140 * rgb[2]\n",
    "    i = 0.5959 * rgb[0] - 0.2746 * rgb[1] - 0.3213 * rgb[2]\n",
    "    q = 0.2115 * rgb[0] - 0.5227 * rgb[1] + 0.3112 * rgb[2]\n",
    "    return (y, i, q)\n",
    "\n",
    "def yiq_to_rgb(yiq: t.Tuple[float, float, float]) -> t.Tuple[int, int, int]:\n",
    "    r = round(max(0, min(255, 1 * yiq[0] + 0.956 * yiq[1] + 0.619 * yiq[2])))\n",
    "    g = round(max(0, min(255, 1 * yiq[0] - 0.272 * yiq[1] - 0.647 * yiq[2])))\n",
    "    b = round(max(0, min(255, 1 * yiq[0] - 1.106 * yiq[1] + 1.703 * yiq[2])))\n",
    "    return (r, g, b)"
   ],
   "execution_count":2,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"KII6yMUE6wl6xa85jV1aHA",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q2 - Pseudocode\n",
    "\n",
    "1. Start with the digital RGB space (256 x 256 x 256)\n",
    "2. Convert to analog YIQ space\n",
    "3. Calculate the YIQ range\n",
    "4. Reverse the YIQ range to RGB to check for (near)reversibility"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"vvLe080RvnC3y929HdnwC0",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "y_rng = [float('inf'), float('-inf')]\n",
    "i_rng = [float('inf'), float('-inf')]\n",
    "q_rng = [float('inf'), float('-inf')]\n",
    "tot = 256 * 256 * 256\n",
    "r1 = tot\n",
    "r2 = tot\n",
    "lim = 1\n",
    "\n",
    "for r in range(256):\n",
    "    for g in range(256):\n",
    "        for b in range(256):\n",
    "            (r_in, g_in, b_in) = (r, g, b)\n",
    "            (y, i, q) = rgb_to_yiq((r_in, g_in, b_in))\n",
    "            (r_out, g_out, b_out) = yiq_to_rgb((y, i, q))\n",
    "            y_rng = (min(y_rng[0], y), max(y_rng[1], y))\n",
    "            i_rng = (min(i_rng[0], i), max(i_rng[1], i))\n",
    "            q_rng = (min(q_rng[0], q), max(q_rng[1], q))\n",
    "            if not all([r_in == r_out, g_in == g_out, b_in == b_out]):\n",
    "                r1 -= 1\n",
    "            if not all([abs(r_in - r_out) <= lim, abs(g_in - g_out) <= lim, (b_in - b_out) <= lim]):\n",
    "                r2 -= 1\n",
    "\n",
    "print('--- using custom colors conversion ---')\n",
    "print(f'Y: [{y_rng[0]}, {y_rng[1]}]')\n",
    "print(f'I: [{i_rng[0]}, {i_rng[1]}]')\n",
    "print(f'Q: [{q_rng[0]}, {q_rng[1]}]')\n",
    "print(f'{100 * r1 \/ tot} % of the space is perfectly reversible ({r1}\/{tot})')\n",
    "print(f'{100 * r2 \/ tot} % of the space is near perfectly (diff <= {lim}) reversible ({r2}\/{tot})')\n",
    "\n",
    "del y_rng, i_rng, q_rng, tot, r1, r2, lim, r_in, g_in, b_in, r, g, b, y, i, q, r_out, g_out, b_out"
   ],
   "execution_count":3,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"Bv8PbctbsICC9uQZSBW6Pg",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q2 - Results\n",
    "\n",
    "Using the custom color space conversion\n",
    "\n",
    "* The RGB space is [0, 255]\n",
    "* The RGB space [0, 255] x [0, 255] x [0, 255] converts to the YIQ space [0, 255] x [-151.9545, 151.9545] x [-133.2885, 133.2885]\n",
    "* 100 % of the space is perfectly reversible"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"FxYMVvZEIuCDwqU3ZBdhCa",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q3 - Pseudocode\n",
    "\n",
    "1. Start with the analog YIQ space [0, 255] x [-151.9545, 151.9545] x [-133.2885, 133.2885]\n",
    "2. Sample 4 x 256 x 256 x 256 times from the space.\n",
    "   **Note**: This is a probalistic test.\n",
    "3. Convert from  YIQ to RGB\n",
    "4. Check to see if the RGB is outside the bounds of [0, 255]"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"12AuzqTZT3mi1l5FRN1sEB",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "from random import randint, uniform, seed\n",
    "\n",
    "seed(0)\n",
    "\n",
    "y_rng = [0, 255]\n",
    "i_rng = [-151.9545, 151.9545]\n",
    "q_rng = [-133.2885, 133.2885]\n",
    "tot = 4 * 256 * 256 * 256\n",
    "good = tot\n",
    "\n",
    "for _ in range(tot):\n",
    "    y = randint(y_rng[0], y_rng[1])\n",
    "    i = uniform(i_rng[0], i_rng[1])\n",
    "    q = uniform(q_rng[0], q_rng[1])\n",
    "    (r, g, b) = yiq_to_rgb((y, i, q))\n",
    "    if not all([0 <= r, r < 256, 0 <= g, g < 256, 0 <= b, b < 256]):\n",
    "        good -= 1\n",
    "\n",
    "print(f'{100 * good \/ tot} % of the YIQ space is addressable as RGB ({good}\/{tot})')\n",
    "\n",
    "del y_rng, i_rng, q_rng, tot, good, y, i, q, r, g, b"
   ],
   "execution_count":4,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"yPLksRItFTQ3WhuGbiFFC1",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "## Q3 - Results\n",
    "\n",
    "* Thanks to clamping 100 % of the YIQ space is addressable as RGB"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"V1vGpJNfwgEvsbZBHRd6sU",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"markdown",
   "source":[
    "# Generate Static - YIQ\/RGB (color + BW)\n",
    "\n",
    "## Pseudo Code - YIQ\n",
    "\n",
    "1. Generate random numbers\n",
    "2. Interpret those values as NTSC values.\n",
    "   NTSC uses YIQ as the color space\n",
    "3. Convert YIQ to RGB\n",
    "4. Save the images as a PNG\n",
    "5. Repeat\n",
    "\n",
    "## Pseudo Code - RGB\n",
    "\n",
    "1. Generate random numbers\n",
    "2. Interpret those values as RGB values.\n",
    "3. Save the images as a PNG\n",
    "4. Repeat\n"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"piRK4Ukkp4D1WzPTpTDcHP",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "import pathlib\n",
    "import progressbar as pb # type: ignore\n",
    "import random\n",
    "import shutil\n",
    "import sys\n",
    "from PIL import Image\n",
    "\n",
    "# the size and count of the images\n",
    "w = 480\n",
    "h = 320\n",
    "n = 50000\n",
    "seed = 0\n",
    "\n",
    "# setup folder\n",
    "def ensure_folder(path: pathlib.Path) -> None:\n",
    "    if path.exists():\n",
    "        shutil.rmtree(path)\n",
    "    path.mkdir(parents = True)\n",
    "\n",
    "# fill the image with static\n",
    "def generate_static_yiq(img: Image.Image, depth: str) -> None:\n",
    "    y_rng = [0, 255]\n",
    "    i_rng = [-151.9545, 151.9545]\n",
    "    q_rng = [-133.2885, 133.2885]\n",
    "    for w in range(img.width):\n",
    "        for h in range(img.height):\n",
    "            y = random.randint(y_rng[0], y_rng[1])\n",
    "            if depth == 'bw':\n",
    "                i = q = 0                \n",
    "            elif depth == 'color':\n",
    "                i = random.uniform(i_rng[0], i_rng[1])\n",
    "                q = random.uniform(q_rng[0], q_rng[1])                \n",
    "            rgb = yiq_to_rgb((y, i, q))\n",
    "            img.putpixel((w, h), rgb)\n",
    "def generate_static_rgb(img: Image.Image, depth: str) -> None:\n",
    "    r_rng = [0, 255]\n",
    "    g_rng = [0, 255]\n",
    "    b_rng = [0, 255]\n",
    "    for w in range(img.width):\n",
    "        for h in range(img.height):\n",
    "            r = random.randint(r_rng[0], r_rng[1])\n",
    "            if depth == 'bw':\n",
    "                g = b = r                \n",
    "            elif depth == 'color':\n",
    "                g = random.randint(g_rng[0], g_rng[1])\n",
    "                b = random.randint(b_rng[0], b_rng[1])                \n",
    "            img.putpixel((w, h), (r, g, b))\n",
    "\n",
    "color_space = {'yiq': generate_static_yiq, 'rgb': generate_static_rgb}\n",
    "color_depth = ['bw', 'color']\n",
    "\n",
    "# run the loop\n",
    "for space in color_space:\n",
    "    for depth in color_depth:\n",
    "        # consistency\n",
    "        random.seed(seed)\n",
    "        # calculated settings\n",
    "        path = pathlib.Path(f'\/data\/notebook_files\/{space}\/{depth}')\n",
    "        ensure_folder(path)\n",
    "        print(f'--- {n} {w}x{h} {depth} images from {space} (seed {seed}) ---')\n",
    "        widgets = [pb.Counter(), ' ', pb.Timer(), ' ', pb.BouncingBar(marker = '.', left = '[', right = ']')]\n",
    "        with pb.ProgressBar(widgets = widgets, line_breaks = False, fd = sys.stdout) as bar:\n",
    "            bar.update(0) # type: ignore\n",
    "            for cnt in range(n):\n",
    "                with Image.new(mode = \"RGB\", size = (w, h)) as img:\n",
    "                    color_space[space](img, depth)\n",
    "                    img.save(path.joinpath(f'{cnt:05d}.png'))\n",
    "                    bar.update(cnt) # type: ignore\n",
    "\n",
    "del w, h, n, seed, color_space, color_depth, space, depth, path, widgets, bar, img, cnt"
   ],
   "execution_count":5,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"cy4x5pHYaD5HJ0L5eAvUV6",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  }
 ],
 "metadata":{
  "kernelspec":{
   "display_name":"Python",
   "language":"python",
   "name":"python"
  },
  "datalore":{
   "version":1,
   "computation_mode":"JUPYTER",
   "package_manager":"pip",
   "base_environment":"minimal",
   "packages":[
    {
     "name":"progressbar2",
     "version":"3.55.0",
     "source":"PIP"
    }
   ]
  }
 },
 "nbformat":4,
 "nbformat_minor":4
}