05_Imputed_Congestion_Map_and_Bargraph_Animation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8fed0412",
   "metadata": {},
   "source": [
    "# Imputed Congestion Map and Bargraph Animation\n",
    "## Notebook 5/7\n",
    "\n",
    "## Gabriel del Valle\n",
    "## 07/21/24\n",
    "## NYC DATA SCIENCE ACADEMY\n",
    "\n",
    "### For any questions about this project or to request full map videos or datasets, please feel free to reach out on Linkedin: \n",
    "\n",
    "   www.linkedin.com/in/gabriel-del-valle-147616152\n",
    "\n",
    "   gabrielxdelvalle@gmail.com\n",
    "\n",
    "\n",
    "### This notebook is the same as the previous but using the imputed_congestion.csv dataset\n",
    "\n",
    "This python jupyter notebook contains several functions that can be used together to produce a video of a Manhattan Congestion Zone Map, displaying average volume per street per datetime.\n",
    " \n",
    "As well, this notebook follows a similar process to create a video of a bargraph which corresponds to the animated congestion map, producing a bar graph, labeled by street, measuring the traffic volume for each datetime frame. The colors of the bars represent congestion with the same colors used in the map.\n",
    "\n",
    "The videos of the map and the bargraph which are the products of this notebook can be played side by side and will correspond as a single video.\n",
    "\n",
    "This notebook will outline the steps for animating the entire dataset, which is 1 hour 39 minutes long. However, the functions can easily be used to produce a shorter slice of video given a start and an end row.\n",
    "\n",
    "It takes hours to render the whole czone_October dataset, but on my macbook frames are produced almost once per second. \n",
    "\n",
    "\n",
    "## Functions:\n",
    "\n",
    "### standardize_street_names( )\n",
    "    \n",
    "    Makes all street names 30 characters for the bargraph video, so image sizes stay standard\n",
    "\n",
    "### animate_bargraph_img( )\n",
    "    \n",
    "    Given a datetime interval produces a bargraph displaying street names in a descending order bargraph of vol, bars colored with the congestion value. Generates single image per datetime.\n",
    "\n",
    "### animate_bargraph( )\n",
    "\n",
    "    Given a start row and a number of rows to generate, loops through the datetime range of the congestion_streets dataset and inputs them into animate_bragraph_img()\n",
    "\n",
    "### plot_congestion_anim( )\n",
    "\n",
    "    Given a datetime, generate a Manhattan Congestion Relief Zone map which displays the congestion values of each street recorded in congestion_streets, as a color from green to yellow to red (representing 0.0 to 1.0)\n",
    "\n",
    "### animate_map( )\n",
    "\n",
    "    Given a start row and a number of rows to generate, loops through the datetime range of the congestion_streets dataset and inputs them into plot_congestion_anim()\n",
    "    \n",
    "### image_names()\n",
    "\n",
    "    Given a start row and an end row corresponding to the congestion_streets dataset, image_names() produces a list of strings with the same date and index based naming schemes as plot_congestion_anim() and animate_bargraph_img().\n",
    "    \n",
    "    This is useful to quickly generate a list of specific files for operations in the video making process that require file names.\n",
    "    \n",
    "    \n",
    "###  multiply_frames( )\n",
    "\n",
    "    For the purpose of creating videos with the CV2 library, which has a minimum framerate of 24 frames per second. \n",
    "\n",
    "    In order to see each frame for half a second, multiply frames by 12\n",
    "\n",
    "    Exports new multiplied frames to a new directory, divides names with a letter suffix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "88f209ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import geopandas as gpd\n",
    "from shapely.geometry import MultiLineString, LineString\n",
    "import re\n",
    "import os\n",
    "import cv2\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import get_cmap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5a56c49",
   "metadata": {},
   "source": [
    "## Import datasets:\n",
    "\n",
    "### congestion_streets.csv\n",
    "\n",
    "    Created in the previous notebook which adds to traffic data a measure of congestion -- a relative measure of street business: \n",
    "\n",
    "    congestion = current street volume / maximum volume of street\n",
    "    \n",
    "    scale 0.0 to 1.0\n",
    "\n",
    "\n",
    "### czone_json.geojson\n",
    "\n",
    "    The geojson map file which is prepared to work with the congestion_streets dataset, sharing a naming scheme and corresponding streets. \n",
    "    \n",
    "    Contains only streets in the congestion_streets dataset.\n",
    "\n",
    "\n",
    "### base_map.geojson\n",
    "\n",
    "    A full detail map of Manhattan to use underneath czone_json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a88fc3f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# October Traffic Map Data\n",
    "\n",
    "OTMD = pd.read_csv(\"imputed_congestion.csv\")\n",
    "OTMDdates = OTMD['datetime'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4f28b64b",
   "metadata": {},
   "outputs": [],
   "source": [
    "json_streets = gpd.read_file('czone_json.geojson')\n",
    "base_map = gpd.read_file('base_map.geojson')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3902e8d",
   "metadata": {},
   "source": [
    "### Standardize_street_name   -- This function is needed when making the bargraph video. \n",
    "\n",
    "### If the length of a label changes so will the size of the image and the images will be incompatible to create video. \n",
    "\n",
    "### This function effectively fixes this by adding space to make all labels the length of the longest name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b8b740f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize_street_name(street):\n",
    "    \"\"\"Ensures all street names are 30 characters long.\"\"\"\n",
    "    return street.rjust(30)\n",
    "\n",
    "OTMDstreets30 = OTMD.copy()\n",
    "\n",
    "OTMDstreets30['street'] = OTMD['street'].apply(standardize_street_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e6b1f199",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "# Suppress all warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "# Re-enable warnings\n",
    "#warnings.filterwarnings(\"default\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d625409c",
   "metadata": {},
   "source": [
    "### animate_bargraph_img( ) is designed to be called by animate_bargraph( )\n",
    "\n",
    "### Produces a bargraph, in descending order of volume, colored with congestion value, per datetime.\n",
    "\n",
    "### i is used for naming, you can start it at 0 if you wish to use if for a different slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2c04c2e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get congestion color map\n",
    "cmap = get_cmap('RdYlGn_r')\n",
    "\n",
    "#26 spaces so that NA label adds up to 30\n",
    "spaces = \"                          \"\n",
    "alphabetCap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "\n",
    "def animate_bargraph_img(datetime, output_dir, i):\n",
    "    if not os.path.exists(output_dir):\n",
    "        os.makedirs(output_dir)\n",
    "    \n",
    "    data = OTMDstreets30[OTMDstreets30['datetime'] == datetime]\n",
    "    \n",
    "    data20 = data.sort_values(by = 'Vol', ascending = False).head(20)\n",
    "    \n",
    "    \n",
    "    if len(data20) < 20:\n",
    "        needed = 20 - len(data20)\n",
    "        dummy_streets = [f\"{spaces}NA {alphabetCap[j]}\" for j in range(needed)]\n",
    "        dummy_data = pd.DataFrame({\n",
    "            'street': dummy_streets,\n",
    "            'Vol': [0] * needed,\n",
    "            'congestion': [0] * needed\n",
    "        })\n",
    "        data20 = pd.concat([data20, dummy_data], ignore_index=True)\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "    \n",
    "    #fig, ax = plt.subplots()\n",
    "    fig, ax = plt.subplots(figsize=(10, 8))\n",
    "\n",
    "\n",
    "    congestion = data20['congestion']\n",
    "    streets = data20['street']\n",
    "    ax.bar(streets, data20['Vol'], color=[cmap(v) for v in congestion])\n",
    "\n",
    "    y_ticks = np.arange(0, 1501, 100)  # Creates ticks from 0 to 1500, spaced by 100\n",
    "    ax.set_yticks(y_ticks)\n",
    "    \n",
    "    ax.set_title(datetime)\n",
    "    ax.set_xlabel('Street')\n",
    "    ax.set_ylabel('Traffic Volume')\n",
    "    #max_vol_max = OTMD['max_volume'].max()\n",
    "    ax.set_ylim(0, 1500)\n",
    "    \n",
    "    #Monofont keeps the horizontal spacing of x axis ticks the same\n",
    "    #This is curcial for keeping horizontal width constant\n",
    "    #Which is crucial for combining images into a video\n",
    "    ax.set_xticklabels(ax.get_xticklabels(), fontdict={'fontname': 'monospace'})\n",
    "    ax.tick_params(axis='x', rotation=90)  # Rotate x-axis labels\n",
    "\n",
    "    # Save the figure as an image\n",
    "    output_file = os.path.join(f'bargraph_{datetime}.png')\n",
    "    output_path = f'{output_dir}/{output_file}'\n",
    "    plt.savefig(output_path, bbox_inches='tight', pad_inches=0.1, dpi = 100)\n",
    "    plt.close()\n",
    "\n",
    "    return output_file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83def629",
   "metadata": {},
   "source": [
    "## The bargraph video is much faster to produce than the map video, and can be done all at once rather than in chunks at a time. \n",
    "\n",
    "## output_dir -- name of the folder that will be created in the current directory to save images to\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7aa295c",
   "metadata": {},
   "source": [
    "# Animate_bargraph( ) return: file_names\n",
    "\n",
    "## Names of files that were generated. \n",
    "## Useful later for duplicating frames and making video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b4bfaeb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def animate_bargraph(output_dir, start_row, num_rows):\n",
    "        \n",
    "    file_names = [0] * num_rows\n",
    "    end_row = start_row + num_rows\n",
    "\n",
    "    for i, datetime in enumerate(OTMDdates[start_row:end_row], start=start_row):\n",
    "        if i >= end_row:\n",
    "            break\n",
    "        \n",
    "        file_names[i-start_row] = animate_bargraph_img(datetime, output_dir, i)\n",
    "        \n",
    "    return file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d438113",
   "metadata": {},
   "source": [
    "## plot_congestion_anim( ) designed to be called by animate_map( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "3f0c301c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_congestion_anim(datetime, output_dir, index):\n",
    "    cmap = plt.cm.get_cmap('RdYlGn_r')\n",
    "    geom_pattern = r\"[-+]?\\d*\\.\\d+|\\d+\"\n",
    "    base_map['color'] = 'gray'\n",
    "\n",
    "    # Filter data for the specific datetime\n",
    "    datetime_data = OTMD[OTMD['datetime'] == datetime]\n",
    "\n",
    "    # Create a new figure\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    base_map.plot(ax=ax, color=base_map['color'], edgecolor='black', linewidth=0.5)\n",
    "\n",
    "    # Iterate over each street segment\n",
    "    for _, row in datetime_data.iterrows():\n",
    "        street_name = row['street']\n",
    "        congestion = row['congestion']\n",
    "\n",
    "        # Get geometry of the street segment\n",
    "        street_geometries = list(json_streets[json_streets['st_name'] == street_name]['geometry'])\n",
    "\n",
    "        for street_geometry in street_geometries:\n",
    "            # Extract coordinates from geometry\n",
    "            geometry_string = str(street_geometry)\n",
    "            coordinates = re.findall(geom_pattern, geometry_string)\n",
    "            coordinates = [float(coord) for coord in coordinates]\n",
    "\n",
    "            # Split coordinates into pairs (longitude, latitude)\n",
    "            coordinates_pairs = [(coordinates[i], coordinates[i + 1]) for i in range(0, len(coordinates), 2)]\n",
    "\n",
    "            # Plot the line segment\n",
    "            for i in range(len(coordinates_pairs) - 1):\n",
    "                segment = coordinates_pairs[i:i + 2]\n",
    "                xs, ys = zip(*segment)  # Unzip the segment into x and y coordinates\n",
    "                ax.plot(xs, ys, color=cmap(congestion), linewidth=1)\n",
    "\n",
    "    ax.set_title(f'{datetime}')\n",
    "    plt.axis('off')\n",
    "\n",
    "    # Save the figure as an image\n",
    "    output_file = os.path.join(f'{index:04d}_{datetime}.png')\n",
    "    output_path = f'{output_dir}/{output_file}'\n",
    "    plt.savefig(output_path, bbox_inches='tight', pad_inches=0.1)\n",
    "    plt.close()\n",
    "    return(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9abdf014",
   "metadata": {},
   "source": [
    "# Animate_bargraph( ) return: file_names\n",
    "\n",
    "## Names of files that were generated. \n",
    "## Useful later for duplicating frames and making video"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af7e5f1a",
   "metadata": {},
   "source": [
    "## output_dir -- name of the folder that will be created in the current directory to save images to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "96e10aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def animate_map(output_dir, start_row, num_rows):\n",
    "    \n",
    "    if not os.path.exists(output_dir):\n",
    "        os.makedirs(output_dir)\n",
    "        \n",
    "    file_names = [0] * num_rows\n",
    "    end_row = start_row + num_rows\n",
    "\n",
    "    # Iterate over rows of congave_October starting from start_row\n",
    "    for i, datetime in enumerate(OTMDdates[start_row:end_row], start=start_row):\n",
    "        # Check if we've reached the desired number of rows\n",
    "        if i >= end_row:\n",
    "            break\n",
    "        \n",
    "        # Call the plot_congestion function for the current datetime\n",
    "        file_names[i-start_row] = plot_congestion_anim(datetime, output_dir, i)\n",
    "        \n",
    "    return file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29adc8e7",
   "metadata": {},
   "source": [
    "## Important Note: attempting to generate more than 1000 frames at a time using animate_map( ) can cause python kernel to crash. 1000 at a time worked reliably for my macbook m3 pro"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1be525d8",
   "metadata": {},
   "source": [
    "### image_names( ) works for reproducing both bargraph and map image names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "39a52b8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def image_names(start_row, num_rows):\n",
    "    file_names = [0] * num_rows\n",
    "    end_row = start_row + num_rows\n",
    "    for i, datetime in enumerate(OTMDdates[start_row:end_row], start=start_row):\n",
    "        # Check if we've reached the desired number of rows\n",
    "        if i >= end_row:\n",
    "            break\n",
    "        \n",
    "        output_file = os.path.join(f'{i:04d}_{datetime}.png')\n",
    "        file_names[i-start_row] = output_file\n",
    "\n",
    "    return file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27fd0564",
   "metadata": {},
   "source": [
    "## multiply_frames( )\n",
    "## For the purpose of creating videos with the CV2 library, which has a minimum framerate of 24 frames per second. \n",
    "\n",
    "## In order to see each frame for half a second, multiply frames by 12\n",
    "\n",
    "## Exports new multiplied frames to a new directory, divides names with a letter suffix\n",
    "\n",
    "## factor = multiplication rate\n",
    "\n",
    "## filenames = list of filenames, such as the result of running animate_map( ) or animate_bargraph( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e83ccbdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "\n",
    "\n",
    "alphabet = 'abcdefghijklmnopqrstuvwxyz'\n",
    "\n",
    "def multiply_frames(factor, input_directory, output_directory, file_names):\n",
    "    # Check if input directory exists\n",
    "    if not os.path.exists(input_directory):\n",
    "        raise FileNotFoundError(f\"The directory {input_directory} does not exist.\")\n",
    "        \n",
    "    num_files = len(file_names) * factor\n",
    "    new_file_names = [0] * num_files\n",
    "    index = 0\n",
    "    \n",
    "    # Create the output directory if it doesn't exist\n",
    "    if not os.path.exists(output_directory):\n",
    "        os.makedirs(output_directory)\n",
    "    \n",
    "    \n",
    "    # Process each file in the file_names list\n",
    "    for title in file_names:\n",
    "        file_path = os.path.join(input_directory, title)\n",
    "        if not os.path.exists(file_path):\n",
    "            continue  # Skip if file does not exist\n",
    "        \n",
    "        # Create duplicates\n",
    "        for i in range(factor):\n",
    "            suffix = alphabet[i % len(alphabet)]\n",
    "            new_title = f\"{title.rsplit('.', 1)[0]}_{suffix}.{title.rsplit('.', 1)[1]}\"\n",
    "            new_file_path = os.path.join(output_directory, new_title)\n",
    "            shutil.copy(file_path, new_file_path)\n",
    "            new_file_names[index] = new_title\n",
    "            index +=1\n",
    "    \n",
    "    return new_file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98b43035",
   "metadata": {},
   "source": [
    "# Generate Congestion Map\n",
    "\n",
    "Number of total frames = number of unique dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a6cf8550",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11852"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(OTMD['datetime'].unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c30c8294",
   "metadata": {},
   "source": [
    "To generate 10716 frames it must be broken into 1000 frames to process at a time, or the python kernel could die. \n",
    "\n",
    "Depending on your machine consider lowering the number of frames per chunk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f3cb8a5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch01 = animate_map(\"ImputedMapFinal\", 0, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "21f0484d",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch02 = animate_map(\"ImputedMapFinal\", 1000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b6d6ad0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch03 = animate_map(\"ImputedMapFinal\", 2000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8243d4c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch04 = animate_map(\"ImputedMapFinal\", 3000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "35e58abc",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch05 = animate_map(\"ImputedMapFinal\", 4000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6832e8b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch06 = animate_map(\"ImputedMapFinal\", 5000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c8549f4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch07 = animate_map(\"ImputedMapFinal\", 6000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2f6900ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch08 = animate_map(\"ImputedMapFinal\", 7000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cbd32b96",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch09 = animate_map(\"ImputedMapFinal\", 8000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9dd7903b",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch10 = animate_map(\"ImputedMapFinal\", 9000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3a6247f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch11 = animate_map(\"ImputedMapFinal\", 10000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6a92ce3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "map_batch12 = animate_map(\"ImputedMapFinal\", 11000, 852)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fac69779",
   "metadata": {},
   "source": [
    "### Use image_names( ) to produce a single list of all the files stored in the 11 different map batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6f909b5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "imp_batch_final = image_names(0, 11852)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3706b146",
   "metadata": {},
   "source": [
    "### Use list of image names with multiply_frames( ) to create 12 of each of the original map frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f379ebc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "imp_batch_final_12frame = multiply_frames(12, \"ImputedMapFinal\", \"ImputedMapFinal_12Frame\", imp_batch_final)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "834317f3",
   "metadata": {},
   "source": [
    "### Join images together into a video at 24 frames per second using image  names list and cv2 library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ba93bdbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n",
    "\n",
    "# Open the first image to get its dimensions\n",
    "first_image_path = f'ImputedMapFinal_12Frame/{imp_batch_final_12frame[0]}'\n",
    "first_image = cv2.imread(first_image_path)\n",
    "frame_width = first_image.shape[1]\n",
    "frame_height = first_image.shape[0]\n",
    "\n",
    "\n",
    "#aspect_ratio = frame_width / frame_height\n",
    "\n",
    "# Initialize the VideoWriter object with the calculated dimensions\n",
    "output_video = cv2.VideoWriter('ImputedMapFinal.mp4', fourcc, 24, (frame_width, frame_height))\n",
    "\n",
    "# Iterate over each image and add it to the video\n",
    "for image in imp_batch_final_12frame:\n",
    "    image_path = f'ImputedMapFinal_12Frame/{image}'\n",
    "    img = cv2.imread(image_path)\n",
    "    output_video.write(img)\n",
    "\n",
    "# Release the VideoWriter object\n",
    "output_video.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ada902d",
   "metadata": {},
   "source": [
    "### Generate frames for the bargaph video, one per datetime:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "6c84561c",
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_batch = animate_bargraph(\"ImputedBarGraph\", 0, 11852)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93120b6c",
   "metadata": {},
   "source": [
    "### Use list of image names with multiply_frames( ) to create 12 of each of the bargraph frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "c27781d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_batch_12frame = multiply_frames(12, \"ImputedBarGraph\", \"ImputedBarGraph_12Frame\", graph_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22f0ecd6",
   "metadata": {},
   "source": [
    "### Join images together into a video at 24 frames per second using image  names list and cv2 library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "681740e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n",
    "\n",
    "# Open the first image to get its dimensions\n",
    "first_image_path = f'ImputedBarGraph_12Frame/{graph_batch_12frame[0]}'\n",
    "first_image = cv2.imread(first_image_path)\n",
    "frame_width = first_image.shape[1]\n",
    "frame_height = first_image.shape[0]\n",
    "\n",
    "\n",
    "#aspect_ratio = frame_width / frame_height\n",
    "\n",
    "# Initialize the VideoWriter object with the calculated dimensions\n",
    "output_video = cv2.VideoWriter('ImputedBarGraph.mp4', fourcc, 24, (frame_width, frame_height))\n",
    "\n",
    "# Iterate over each image and add it to the video\n",
    "for image in graph_batch_12frame:\n",
    "    image_path = f'ImputedBarGraph_12Frame/{image}'\n",
    "    img = cv2.imread(image_path)\n",
    "    output_video.write(img)\n",
    "\n",
    "# Release the VideoWriter object\n",
    "output_video.release()"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}