diff --git a/workspaces/brendon/Applying_LSTM_NETCD_Files.ipynb b/workspaces/brendon/Applying_LSTM_NETCD_Files.ipynb
new file mode 100644
index 0000000..df7c84d
--- /dev/null
+++ b/workspaces/brendon/Applying_LSTM_NETCD_Files.ipynb
@@ -0,0 +1,880 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "id": "1OkqAcTNad2z"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import glob\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "from datetime import datetime\n",
+    "\n",
+    "# Tensorflow\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.models import load_model\n",
+    "from tensorflow.keras.layers import Dense\n",
+    "from tensorflow.keras.layers import LSTM\n",
+    "from tensorflow.keras.callbacks import EarlyStopping\n",
+    "\n",
+    "# sklearn\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "\n",
+    "# Imaging\n",
+    "import imageio.v2 as imageio\n",
+    "from matplotlib.colors import ListedColormap\n",
+    "\n",
+    "# Default year range\n",
+    "years = range(2015, 2016)\n",
+    "\n",
+    "file_type = \"png\"\n",
+    "# data_folder = \"png\"\n",
+    "data_folder = \"png_no_labels\"\n",
+    "# file_type = \"npy\"\n",
+    "# data_folder = \"npy\"\n",
+    "use_existing_npy = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Num GPUs Available:  1\n"
+     ]
+    }
+   ],
+   "source": [
+    "gpus = tf.config.experimental.list_physical_devices(\"GPU\")\n",
+    "print(\"Num GPUs Available: \", len(gpus))\n",
+    "if gpus:\n",
+    "    for gpu in gpus:\n",
+    "        tf.config.experimental.set_memory_growth(gpu, True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_path(parts):\n",
+    "    out_path = \"\"\n",
+    "    for part in parts:\n",
+    "        out_path = out_path + f\"{part}{os.path.sep}\"\n",
+    "\n",
+    "    out_path = out_path.rstrip(os.path.sep)\n",
+    "    return out_path"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example npy file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 435
+    },
+    "id": "Ntz2bU_ca1x5",
+    "outputId": "c478081d-2774-48da-e81c-04ba5e0b4af4"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "npy shape (2000, 2000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "colors = [\"#000000\", \"#FFFFFF\"]\n",
+    "cmap = ListedColormap(colors, name=\"binary_map\", N=len(colors))\n",
+    "\n",
+    "array_2D = np.load(\n",
+    "    r\"D:\\IceDyno\\IMS_images_converted\\2015\\npy\\ims2015001_1km_v1_grid1000.npy\"\n",
+    ")\n",
+    "plt.imshow(array_2D, cmap=cmap)\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"npy shape {array_2D.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example png file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "png shape (480, 640, 4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "colors = [\"#000000\", \"#FFFFFF\"]\n",
+    "cmap = ListedColormap(colors, name=\"binary_map\", N=len(colors))\n",
+    "\n",
+    "array_2D = imageio.imread(\n",
+    "    r\"D:\\IceDyno\\IMS_images_converted\\2015\\png_no_labels\\ims2015001_1km_v1_grid1000.png\"\n",
+    ")\n",
+    "plt.imshow(array_2D, cmap=cmap)\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"png shape {array_2D.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load npy or png files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "wvQrwCAQbkeo",
+    "outputId": "a1a3ac69-6690-4bba-bf89-2f8319000406"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading year: 2015\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>File Name</th>\n",
+       "      <th>Date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>ims2015001_1km_v1.3.nc</td>\n",
+       "      <td>2015-01-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>ims2015002_1km_v1.3.nc</td>\n",
+       "      <td>2015-01-02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>ims2015003_1km_v1.3.nc</td>\n",
+       "      <td>2015-01-03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>ims2015004_1km_v1.3.nc</td>\n",
+       "      <td>2015-01-04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ims2015005_1km_v1.3.nc</td>\n",
+       "      <td>2015-01-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>359</th>\n",
+       "      <td>ims2015361_1km_v1.3.nc</td>\n",
+       "      <td>2015-12-27</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>360</th>\n",
+       "      <td>ims2015362_1km_v1.3.nc</td>\n",
+       "      <td>2015-12-28</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>361</th>\n",
+       "      <td>ims2015363_1km_v1.3.nc</td>\n",
+       "      <td>2015-12-29</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>362</th>\n",
+       "      <td>ims2015364_1km_v1.3.nc</td>\n",
+       "      <td>2015-12-30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>363</th>\n",
+       "      <td>ims2015365_1km_v1.3.nc</td>\n",
+       "      <td>2015-12-31</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>364 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  File Name        Date\n",
+       "0    ims2015001_1km_v1.3.nc  2015-01-01\n",
+       "1    ims2015002_1km_v1.3.nc  2015-01-02\n",
+       "2    ims2015003_1km_v1.3.nc  2015-01-03\n",
+       "3    ims2015004_1km_v1.3.nc  2015-01-04\n",
+       "4    ims2015005_1km_v1.3.nc  2015-01-05\n",
+       "..                      ...         ...\n",
+       "359  ims2015361_1km_v1.3.nc  2015-12-27\n",
+       "360  ims2015362_1km_v1.3.nc  2015-12-28\n",
+       "361  ims2015363_1km_v1.3.nc  2015-12-29\n",
+       "362  ims2015364_1km_v1.3.nc  2015-12-30\n",
+       "363  ims2015365_1km_v1.3.nc  2015-12-31\n",
+       "\n",
+       "[364 rows x 2 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: total: 1.91 s\n",
+      "Wall time: 3.24 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(364, 1228800)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "npy_file = get_path([\"D:\", \"IceDyno\", \"IMS_images_converted\", \"all_data.npy\"])\n",
+    "dfs = []\n",
+    "\n",
+    "if os.path.exists(npy_file) and use_existing_npy:\n",
+    "    ims_dataset = np.load(npy_file)\n",
+    "else:\n",
+    "    ims_dataset = []\n",
+    "    for yr in years:\n",
+    "        print(f\"Loading year: {yr}\")\n",
+    "        root_dir = get_path([\"D:\\IceDyno\", \"IMS_images_converted\", yr, data_folder])\n",
+    "        file_list = glob.glob(get_path([root_dir, f\"*.{file_type}\"]))\n",
+    "        for data_file in file_list:\n",
+    "            if file_type == \"png\":\n",
+    "                ims_data_today = imageio.imread(data_file)\n",
+    "            else:\n",
+    "                ims_data_today = np.load(data_file)\n",
+    "            ims_data_today_flattened = ims_data_today.flatten()\n",
+    "            ims_dataset.append(ims_data_today_flattened)\n",
+    "\n",
+    "        csv_filename = get_path(\n",
+    "            [\"D:\\IceDyno\", \"IMS_images_converted\", yr, \"image_dates.csv\"]\n",
+    "        )\n",
+    "        if os.path.exists(csv_filename):\n",
+    "            df = pd.read_csv(csv_filename, index_col=False)\n",
+    "            dfs.append(df)\n",
+    "\n",
+    "    ims_dataset = np.array(ims_dataset)\n",
+    "\n",
+    "    np.save(npy_file, ims_dataset)\n",
+    "\n",
+    "# Set dataframe that holds indices for image dates\n",
+    "df = pd.concat(dfs, ignore_index=True)\n",
+    "\n",
+    "# Create scaled dataset from input\n",
+    "scaled_dataset = ims_dataset / 255.0\n",
+    "ims_dataset = []  # Free memory\n",
+    "scaled_dataset.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create train/val/train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "V572dRfedc77",
+    "outputId": "087a9b85-6f91-4fcc-8727-02b4f11700fd"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of train: 254\n",
+      "Size of validation: 72\n",
+      "Size of test: 38\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_size = int(len(scaled_dataset) * 0.7)\n",
+    "val_size = int(len(scaled_dataset) * 0.2)\n",
+    "test_size = int(len(scaled_dataset) * 0.1)\n",
+    "\n",
+    "train = scaled_dataset[:train_size]\n",
+    "val = scaled_dataset[train_size : train_size + val_size]\n",
+    "test = scaled_dataset[train_size + val_size :]\n",
+    "\n",
+    "scaled_dataset = []  # Free memory\n",
+    "print(\n",
+    "    f\"Size of train: {len(train)}\\nSize of validation: {len(val)}\\nSize of test: {len(test)}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create time series with lookback = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "id": "aQ9VyYKhdc_r"
+   },
+   "outputs": [],
+   "source": [
+    "# convert an array of values into a dataset matrix\n",
+    "def create_dataset(dataset, look_back=1):\n",
+    "    dataX, dataY = [], []\n",
+    "    for i in range(len(dataset) - look_back - 1):\n",
+    "        a = dataset[i : (i + look_back)]\n",
+    "        dataX.append(a)\n",
+    "        dataY.append(dataset[i + look_back])\n",
+    "    return np.array(dataX), np.array(dataY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "W2jUEEkHddCm",
+    "outputId": "43b7ad1f-a210-406e-e734-e4b65137564e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train X: (252, 1, 1228800)\ttrain Y: (252, 1228800)\n",
+      "val X: (70, 1, 1228800)\tval Y: (70, 1228800)\n",
+      "test X: (36, 1, 1228800)\ttest Y: (36, 1228800)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# reshape into X=t and Y=t+1\n",
+    "look_back = 1\n",
+    "trainX, trainY = create_dataset(train, look_back)\n",
+    "valX, valY = create_dataset(val, look_back)\n",
+    "testX, testY = create_dataset(test, look_back)\n",
+    "\n",
+    "print(f\"train X: {trainX.shape}\\ttrain Y: {trainY.shape}\")\n",
+    "print(f\"val X: {valX.shape}\\tval Y: {valY.shape}\")\n",
+    "print(f\"test X: {testX.shape}\\ttest Y: {testY.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "-zANzqLNddFd",
+    "outputId": "d2e1275e-cf05-4c73-a72f-2f2cbed1c36d"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "reshaped train X: (252, 1, 1228800)\n",
+      "reshaped val X: (70, 1, 1228800)\n",
+      "reshaped test X: (36, 1, 1228800)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# reshape input to be [samples, time steps, features]\n",
+    "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[2]))\n",
+    "valX = np.reshape(valX, (valX.shape[0], 1, valX.shape[2]))\n",
+    "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[2]))\n",
+    "print(\n",
+    "    f\"reshaped train X: {trainX.shape}\\nreshaped val X: {valX.shape}\\nreshaped test X: {testX.shape}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build Conv LSTM model and train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "FgdjEhE-ddIg",
+    "outputId": "ecfe3801-f720-4219-84cc-251310478840",
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "Epoch 1/100\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).\n",
+      "252/252 - 8s - loss: 0.7151 - val_loss: 0.5331 - 8s/epoch - 30ms/step\n",
+      "Epoch 2/100\n",
+      "252/252 - 3s - loss: 0.4460 - val_loss: 0.3217 - 3s/epoch - 12ms/step\n",
+      "Epoch 3/100\n",
+      "252/252 - 3s - loss: 0.2611 - val_loss: 0.1870 - 3s/epoch - 12ms/step\n",
+      "Epoch 4/100\n",
+      "252/252 - 3s - loss: 0.1457 - val_loss: 0.1091 - 3s/epoch - 12ms/step\n",
+      "Epoch 5/100\n",
+      "252/252 - 3s - loss: 0.0796 - val_loss: 0.0687 - 3s/epoch - 12ms/step\n",
+      "Epoch 6/100\n",
+      "252/252 - 3s - loss: 0.0453 - val_loss: 0.0504 - 3s/epoch - 12ms/step\n",
+      "Epoch 7/100\n",
+      "252/252 - 3s - loss: 0.0293 - val_loss: 0.0439 - 3s/epoch - 12ms/step\n",
+      "Epoch 8/100\n",
+      "252/252 - 3s - loss: 0.0228 - val_loss: 0.0423 - 3s/epoch - 12ms/step\n",
+      "Epoch 9/100\n",
+      "252/252 - 3s - loss: 0.0204 - val_loss: 0.0428 - 3s/epoch - 12ms/step\n",
+      "Epoch 10/100\n",
+      "252/252 - 3s - loss: 0.0197 - val_loss: 0.0432 - 3s/epoch - 12ms/step\n",
+      "Epoch 11/100\n",
+      "252/252 - 3s - loss: 0.0195 - val_loss: 0.0437 - 3s/epoch - 12ms/step\n",
+      "Epoch 12/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0440 - 3s/epoch - 12ms/step\n",
+      "Epoch 13/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0442 - 3s/epoch - 12ms/step\n",
+      "Epoch 14/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0445 - 3s/epoch - 12ms/step\n",
+      "Epoch 15/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0446 - 3s/epoch - 12ms/step\n",
+      "Epoch 16/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0445 - 3s/epoch - 12ms/step\n",
+      "Epoch 17/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0448 - 3s/epoch - 12ms/step\n",
+      "Epoch 18/100\n",
+      "252/252 - 3s - loss: 0.0194 - val_loss: 0.0446 - 3s/epoch - 12ms/step\n",
+      "Epoch 18: early stopping\n",
+      "CPU times: total: 12.4 s\n",
+      "Wall time: 1min 1s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\"\"\"\n",
+    "create and fit the LSTM network\n",
+    "run on CPU due to limitations of GPU memory\n",
+    "`mirroredstrategy` will still feed operations to GPU (if available)\n",
+    "\"\"\"\n",
+    "\n",
+    "strategy = tf.distribute.MirroredStrategy()\n",
+    "\n",
+    "with strategy.scope():\n",
+    "    model = Sequential()\n",
+    "    model.add(LSTM(4, input_shape=(1, trainX.shape[2])))\n",
+    "    model.add(Dense(trainX.shape[2]))\n",
+    "\n",
+    "    model.compile(loss=\"mean_squared_error\", optimizer=\"adam\")\n",
+    "\n",
+    "early_stopping = EarlyStopping(monitor=\"val_loss\", patience=10, verbose=1)\n",
+    "with tf.device(\"/CPU:0\"):\n",
+    "    model.fit(\n",
+    "        trainX,\n",
+    "        trainY,\n",
+    "        epochs=100,\n",
+    "        batch_size=1,\n",
+    "        verbose=2,\n",
+    "        callbacks=[early_stopping],\n",
+    "        validation_data=(valX, valY),\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "today = datetime.today()\n",
+    "formatted_date = today.strftime(\"%m%d%y\")\n",
+    "model.save(f\"{formatted_date}_{file_type}.h5\")\n",
+    "model = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tf.keras.backend.clear_session()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Due to memory constraints on GPU, predict using CPU\n",
+    "with tf.device(\"/CPU:0\"):\n",
+    "    model = tf.keras.models.load_model(f\"{formatted_date}_{file_type}.h5\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "hyA0JQKsddLV",
+    "outputId": "ae83fd5f-289a-4e52-9dd5-fa7dc45cd221"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8/8 [==============================] - 1s 58ms/step\n",
+      "2/2 [==============================] - 0s 13ms/step\n",
+      "Test predict shape: (36, 1228800)\n",
+      "Test predict full array: [[0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n",
+      " [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n",
+      " [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n",
+      " ...\n",
+      " [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n",
+      " [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n",
+      " [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]]\n",
+      "Test predict sample image: [0.99999547 0.99999547 0.99999547 ... 0.99999547 0.99999547 0.99999547]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# make predictions\n",
+    "with tf.device(\"/CPU:0\"):\n",
+    "    trainPredict = model.predict(trainX)\n",
+    "    testPredict = model.predict(testX)\n",
+    "print(f\"Test predict shape: {testPredict.shape}\")\n",
+    "print(f\"Test predict full array: {testPredict}\")\n",
+    "print(f\"Test predict sample image: {testPredict[0]}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "d5WKozowddOD",
+    "outputId": "db7b58a8-925e-40e8-d32b-b1f17ab2bd55",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# We can reshape the output dataframe into the origional format\n",
+    "if file_type == \"npy\":\n",
+    "    testPredict[0].reshape(2000, 2000)\n",
+    "else:\n",
+    "    testPredict[0].reshape(480, 640, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Vax0w0uZeqeU",
+    "outputId": "62ac1200-d508-42f4-87d9-d3c28008f483"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(252, 1228800)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainY.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "VueX4jnMeqhU",
+    "outputId": "71b9be82-8540-4d00-c182-dfa8d9724727"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.012317438098051841"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = trainPredict[0]\n",
+    "B = testY[0]\n",
+    "mse = ((A - B) ** 2).mean()\n",
+    "mse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Convert predictions to [0, 255] same as input data\n",
+    "def transform(in_array):\n",
+    "    # Change predicted values to scale of 255\n",
+    "    scaled_array = in_array * 255\n",
+    "\n",
+    "    # Change scale to integers\n",
+    "    int_array = np.round(scaled_array).astype(int)\n",
+    "\n",
+    "    # Set values , 128 to 0 (black) and >= 128 255 (white)\n",
+    "    int_array[int_array < 128] = 0\n",
+    "    int_array[int_array >= 128] = 255\n",
+    "\n",
+    "    return int_array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "converted_testPredict = transform(testPredict)\n",
+    "converted_testY = transform(testY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 435
+    },
+    "id": "qVnoEexleqka",
+    "outputId": "af830f35-135e-4add-a494-116eff60f668"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if file_type == \"npy\":\n",
+    "    plt.imshow(testPredict[0].reshape(2000, 2000), cmap=cmap, interpolation=\"nearest\")\n",
+    "else:\n",
+    "    image_date = df.loc[0, \"Date\"]\n",
+    "    plt.imshow(\n",
+    "        converted_testPredict[0].reshape(480, 640, 4),\n",
+    "        cmap=cmap,\n",
+    "        interpolation=\"nearest\",\n",
+    "    )\n",
+    "    plt.title(image_date)\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 435
+    },
+    "id": "gyVDCBk4eqne",
+    "outputId": "eab99229-76cd-4704-b435-628b5db6aa4d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if file_type == \"npy\":\n",
+    "    plt.imshow(testY[0].reshape(2000, 2000), cmap=cmap, interpolation=\"nearest\")\n",
+    "else:\n",
+    "    plt.imshow(\n",
+    "        converted_testY[0].reshape(480, 640, 4), cmap=cmap, interpolation=\"nearest\"\n",
+    "    )\n",
+    "    image_date = df.loc[len(train) + len(val), \"Date\"]\n",
+    "    plt.title(image_date)\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/workspaces/brendon/IMS_2_Binary_NPY.ipynb b/workspaces/brendon/IMS_2_Binary_NPY.ipynb
new file mode 100644
index 0000000..860bd2b
--- /dev/null
+++ b/workspaces/brendon/IMS_2_Binary_NPY.ipynb
@@ -0,0 +1,442 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "111f4ff3",
+   "metadata": {},
+   "source": [
+    "## Notebook libraries/Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8e3380fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import glob\n",
+    "from datetime import datetime, timezone\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
+    "from matplotlib.colors import ListedColormap\n",
+    "\n",
+    "import xarray as xr\n",
+    "\n",
+    "from PIL import Image\n",
+    "\n",
+    "import warnings\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\", category=UserWarning)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db5dcc89",
+   "metadata": {},
+   "source": [
+    "### Define path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3b7558e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_path(parts):\n",
+    "    out_path = \"\"\n",
+    "    for part in parts:\n",
+    "        out_path = out_path + f\"{part}{os.path.sep}\"\n",
+    "\n",
+    "    out_path = out_path.rstrip(os.path.sep)\n",
+    "    return out_path"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0a605eb",
+   "metadata": {},
+   "source": [
+    "### Get x, y from longitude, latitude"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "92dc0be1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _hemi_direction(hemisphere):\n",
+    "    \"\"\"Return `1` for 'north' and `-1` for 'south'\"\"\"\n",
+    "    return {\"north\": 1, \"south\": -1}[hemisphere]\n",
+    "\n",
+    "\n",
+    "def polar_lonlat_to_xy(longitude, latitude, true_scale_lat, re, e, hemisphere):\n",
+    "    \"\"\"Convert from geodetic longitude and latitude to Polar Stereographic\n",
+    "    (X, Y) coordinates in km.\n",
+    "\n",
+    "    Args:\n",
+    "        longitude (float): longitude or longitude array in degrees\n",
+    "        latitude (float): latitude or latitude array in degrees (positive)\n",
+    "        true_scale_lat (float): true-scale latitude in degrees\n",
+    "        re (float): Earth radius in km\n",
+    "        e (float): Earth eccentricity\n",
+    "        hemisphere ('north' or 'south'): Northern or Southern hemisphere\n",
+    "\n",
+    "    Returns:\n",
+    "        If longitude and latitude are scalars then the result is a\n",
+    "        two-element list containing [X, Y] in km.\n",
+    "        If longitude and latitude are numpy arrays then the result will be a\n",
+    "        two-element list where the first element is a numpy array containing\n",
+    "        the X coordinates and the second element is a numpy array containing\n",
+    "        the Y coordinates.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    hemi_direction = _hemi_direction(hemisphere)\n",
+    "\n",
+    "    lat = abs(latitude) * np.pi / 180\n",
+    "    lon = longitude * np.pi / 180\n",
+    "    slat = true_scale_lat * np.pi / 180\n",
+    "\n",
+    "    e2 = e * e\n",
+    "\n",
+    "    # Snyder (1987) p. 161 Eqn 15-9\n",
+    "    t = np.tan(np.pi / 4 - lat / 2) / (\n",
+    "        (1 - e * np.sin(lat)) / (1 + e * np.sin(lat))\n",
+    "    ) ** (e / 2)\n",
+    "\n",
+    "    if abs(90 - true_scale_lat) < 1e-5:\n",
+    "        # Snyder (1987) p. 161 Eqn 21-33\n",
+    "        rho = 2 * re * t / np.sqrt((1 + e) ** (1 + e) * (1 - e) ** (1 - e))\n",
+    "    else:\n",
+    "        # Snyder (1987) p. 161 Eqn 21-34\n",
+    "        tc = np.tan(np.pi / 4 - slat / 2) / (\n",
+    "            (1 - e * np.sin(slat)) / (1 + e * np.sin(slat))\n",
+    "        ) ** (e / 2)\n",
+    "        mc = np.cos(slat) / np.sqrt(1 - e2 * (np.sin(slat) ** 2))\n",
+    "        rho = re * mc * t / tc\n",
+    "\n",
+    "    x = rho * hemi_direction * np.sin(hemi_direction * lon)\n",
+    "    y = -rho * hemi_direction * np.cos(hemi_direction * lon)\n",
+    "    return (x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddeab64d",
+   "metadata": {},
+   "source": [
+    "### Crop files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "1e7d6666",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def crop_files(dir_list, center_coordinates, npy_save_dir, png_save_dir) -> None:\n",
+    "    # Set binary colors to black and white\n",
+    "    colors = [\"#000000\", \"#FFFFFF\"]\n",
+    "    cmap = ListedColormap(colors, name=\"binary_map\", N=len(colors))\n",
+    "\n",
+    "    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=0, vmax=1))\n",
+    "    sm.set_array([])\n",
+    "\n",
+    "    samples = {}\n",
+    "\n",
+    "    for cdf_filepath in dir_list:\n",
+    "        # Set output file name and check if the output file already exists on disk.\n",
+    "        npy_output_filename = get_path(\n",
+    "            [\n",
+    "                npy_save_dir,\n",
+    "                os.path.basename(cdf_filepath).split(\".\")[0]\n",
+    "                + f\"_grid{window_size}.npy\",\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "        png_output_filename = get_path(\n",
+    "            [\n",
+    "                png_save_dir,\n",
+    "                os.path.basename(cdf_filepath).split(\".\")[0]\n",
+    "                + f\"_grid{window_size}.png\",\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "        # Open the original NetCDF file\n",
+    "        ds = xr.open_dataset(cdf_filepath)\n",
+    "\n",
+    "        # Get date of image\n",
+    "        dt64 = ds[\"time\"][0].values\n",
+    "        formatted_date = np.datetime_as_string(dt64, unit=\"D\")\n",
+    "\n",
+    "        \"\"\"\n",
+    "        Crop image\n",
+    "        \"\"\"\n",
+    "\n",
+    "        # Expects self.center_coordinates x,y to be \"x, y\" float values.\n",
+    "        # `* 1000` from km to meters\n",
+    "        x, y = center_coordinates\n",
+    "        x = x * 1000\n",
+    "        y = y * 1000\n",
+    "        window = window_size * 1000\n",
+    "\n",
+    "        cropped_ds = ds.sel(\n",
+    "            x=slice(x - window, x + window),\n",
+    "            y=slice(y - window, y + window),\n",
+    "        )\n",
+    "        sie = cropped_ds.IMS_Surface_Values\n",
+    "\n",
+    "        ds.close()\n",
+    "\n",
+    "        # Rotate image and set numpy array\n",
+    "        sie = np.rot90(sie, 2)\n",
+    "        array_2D = sie[0, :, :]\n",
+    "        \"\"\"\n",
+    "        ONLY APPLY FOR BLACK-AND-WHITE PLOTS\n",
+    "        + Set all all non-3 values to 0\n",
+    "        + Set all 3 values to 1\n",
+    "        \"\"\"\n",
+    "        array_2D[array_2D != 3] = 0\n",
+    "        array_2D[array_2D == 3] = 1\n",
+    "\n",
+    "        # Save npy file\n",
+    "        if not os.path.exists(npy_output_filename):\n",
+    "            np.save(npy_output_filename, array_2D)\n",
+    "\n",
+    "        # Save png file\n",
+    "        #         png_data = array_2D.astype(np.uint8)\n",
+    "        #         png_img = Image.fromarray(array_2D)\n",
+    "        #         png_img.show()\n",
+    "        #         png_img.save(png_output_filename)\n",
+    "        if not os.path.exists(png_output_filename):\n",
+    "            plt.imshow(array_2D, cmap=cmap)\n",
+    "            plt.title(formatted_date, fontsize=16)\n",
+    "            plt.savefig(png_output_filename)\n",
+    "\n",
+    "        # Add image to sample dict\n",
+    "        if formatted_date[-3:] == \"-01\":\n",
+    "            samples[formatted_date] = array_2D\n",
+    "\n",
+    "    \"\"\"\n",
+    "    Plot sample images\n",
+    "    \"\"\"\n",
+    "    fig, axs = plt.subplots(3, 4, figsize=(16, 5))\n",
+    "    axs = axs.flatten()\n",
+    "\n",
+    "    for i, sample_date in enumerate(samples):\n",
+    "        axs[i].imshow(\n",
+    "            samples[sample_date],\n",
+    "            cmap=cmap,\n",
+    "            vmin=0,\n",
+    "            vmax=len(colors) - 1,\n",
+    "        )\n",
+    "        axs[i].set_title(sample_date, fontsize=14)\n",
+    "        axs[i].axis(\"off\")\n",
+    "\n",
+    "    divider = make_axes_locatable(axs[len(samples) - 1])\n",
+    "    cbar_ax = divider.append_axes(\"right\", size=\"10%\", pad=0.1)\n",
+    "    cbar = plt.colorbar(\n",
+    "        sm, cax=cbar_ax, ticks=np.arange(len(colors)), ax=axs.ravel().tolist()\n",
+    "    )\n",
+    "    cbar.ax.set_yticklabels(\n",
+    "        [\n",
+    "            \"Not Sea Ice\",\n",
+    "            \"Sea Ice\",\n",
+    "        ],\n",
+    "        fontsize=14,\n",
+    "    )\n",
+    "    cbar.set_label(\"Surface Types\", fontsize=16)\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6508ee8a",
+   "metadata": {},
+   "source": [
+    "### Assign defaults"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b3a7c348",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "analysis_years = range(2015, 2025)\n",
+    "root_dir = get_path([\"D:\", \"IceDyno\", \"IMS_Images\"])\n",
+    "\n",
+    "# coordinates\n",
+    "TRUE_SCALE_LATITUDE = 70\n",
+    "EARTH_RADIUS_KM = 6378.273\n",
+    "EARTH_ECCENTRICITY = 0.081816153\n",
+    "beaufort_sea_long = -75.0\n",
+    "beaufort_sea_lat = 74.0\n",
+    "\n",
+    "center_coordinates = polar_lonlat_to_xy(\n",
+    "    beaufort_sea_long,\n",
+    "    beaufort_sea_lat,\n",
+    "    TRUE_SCALE_LATITUDE,\n",
+    "    EARTH_RADIUS_KM,\n",
+    "    EARTH_ECCENTRICITY,\n",
+    "    \"north\",\n",
+    ")\n",
+    "\n",
+    "window_size = 1000"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d8c5308",
+   "metadata": {},
+   "source": [
+    "## Process files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3fc0aa3c",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cropping files for 2015\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x500 with 13 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cropping files for 2016\n"
+     ]
+    }
+   ],
+   "source": [
+    "for yr in analysis_years:\n",
+    "    print(f\"Cropping files for {yr}\")\n",
+    "    hdf5_dir = get_path([root_dir, yr])\n",
+    "    npy_save_dir = get_path([hdf5_dir, \"npy\"])\n",
+    "    os.makedirs(npy_save_dir, exist_ok=True)\n",
+    "    png_save_dir = get_path([hdf5_dir, \"png\"])\n",
+    "    os.makedirs(png_save_dir, exist_ok=True)\n",
+    "\n",
+    "    file_list = glob.glob(get_path([hdf5_dir, \"*.nc\"]))\n",
+    "    crop_files(file_list, center_coordinates, npy_save_dir, png_save_dir)"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "04944d72",
+   "metadata": {},
+   "source": [
+    "TRUE_SCALE_LATITUDE = 70\n",
+    "EARTH_RADIUS_KM = 6378.273\n",
+    "EARTH_ECCENTRICITY = 0.081816153\n",
+    "beaufort_sea_long = -75.0\n",
+    "beaufort_sea_lat = 74.0\n",
+    "\n",
+    "center_coordinates = polar_lonlat_to_xy(beaufort_sea_long, beaufort_sea_lat,\n",
+    "                                        TRUE_SCALE_LATITUDE, EARTH_RADIUS_KM,\n",
+    "                                        EARTH_ECCENTRICITY, 'north')\n",
+    "\n",
+    "window_size = 1000\n",
+    "\n",
+    "ds = xr.open_dataset(r\"D:\\IceDyno\\IMS_images\\2015\\ims2015001_1km_v1.3.nc\")\n",
+    "\n",
+    "dt64 = ds[\"time\"][0].values\n",
+    "formatted_date = np.datetime_as_string(dt64, unit='D')\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "Crop image\n",
+    "\"\"\"\n",
+    "\n",
+    "# Expects self.center_coordinates x,y to be \"x, y\" float values.\n",
+    "# Coordinates adjusted `* 250` for offset\n",
+    "x, y = center_coordinates\n",
+    "x = x * 1000\n",
+    "y = y * 1000\n",
+    "\n",
+    "window = window_size * 1000  # from km to meters\n",
+    "\n",
+    "cropped_ds = ds.sel(\n",
+    "    x=slice(x - window, x + window),\n",
+    "    y=slice(y - window, y + window),\n",
+    ")\n",
+    "\n",
+    "sie = cropped_ds.IMS_Surface_Values\n",
+    "\n",
+    "ds.close()\n",
+    "\n",
+    "# Rotate image and set numpy array\n",
+    "sie = np.rot90(sie, 2)\n",
+    "array_2D = sie[0, :, :]\n",
+    "\n",
+    "plt.imshow(array_2D)\n",
+    "plt.show()\n",
+    "\n",
+    "# sie = cropped_ds.IMS_Surface_Values\n",
+    "\n",
+    "ds.close()"
+   ]
+  }
+ ],
+ "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/workspaces/brendon/border_edge_detection.ipynb b/workspaces/brendon/border_edge_detection.ipynb
new file mode 100644
index 0000000..e4c7840
--- /dev/null
+++ b/workspaces/brendon/border_edge_detection.ipynb
@@ -0,0 +1,115 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1d96aa87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.interpolate import interp1d\n",
+    "\n",
+    "binary_array = np.load(r\"D:\\IceDyno\\IMS_images\\2015\\npy\\ims2015001_1km_v1_grid1000.npy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "b8bd00fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x2000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def find_edges(matrix):\n",
+    "    edges = []\n",
+    "    rows = len(matrix)\n",
+    "    cols = len(matrix[0])\n",
+    "\n",
+    "    # Check horizontal edges\n",
+    "    for i in range(rows):\n",
+    "        for j in range(cols - 1):\n",
+    "            if matrix[i][j] != matrix[i][j + 1]:\n",
+    "                edges.append(((i, j), (i, j + 1)))\n",
+    "\n",
+    "    # Check vertical edges\n",
+    "    for j in range(cols):\n",
+    "        for i in range(rows - 1):\n",
+    "            if matrix[i][j] != matrix[i + 1][j]:\n",
+    "                edges.append(((i, j), (i + 1, j)))\n",
+    "\n",
+    "    return edges\n",
+    "\n",
+    "\n",
+    "edges = find_edges(binary_array)\n",
+    "\n",
+    "plt.figure(figsize=(20, 20))\n",
+    "plt.imshow(binary_array, cmap=\"binary\", interpolation=\"nearest\")\n",
+    "\n",
+    "# all_edges = []\n",
+    "for edge in edges:\n",
+    "    plt.plot(\n",
+    "        [edge[0][1], edge[1][1]], [edge[0][0], edge[1][0]], color=\"red\", marker=\".\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "plt.title(\"Computed Edges\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "fbb39b81",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2000"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(binary_array[0])"
+   ]
+  }
+ ],
+ "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/workspaces/brendon/video_from_png.ipynb b/workspaces/brendon/video_from_png.ipynb
new file mode 100644
index 0000000..57bdd57
--- /dev/null
+++ b/workspaces/brendon/video_from_png.ipynb
@@ -0,0 +1,116 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "420a107f",
+   "metadata": {},
+   "source": [
+    "# Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "732fc0f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import os\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ce737a22",
+   "metadata": {},
+   "source": [
+    "# Create video"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1ea058de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_folder = r\"D:\\IceDyno\\IMS_Images\\2015\\png\"\n",
+    "video_name = r\"D:\\IceDyno\\IMS_Images\\2015\\2015.avi\"\n",
+    "\n",
+    "images = [img for img in os.listdir(image_folder) if img.endswith(\".png\")]\n",
+    "frame = cv2.imread(os.path.join(image_folder, images[0]))\n",
+    "height, width, layerrs = frame.shape\n",
+    "\n",
+    "video = cv2.VideoWriter(video_name, 0, 1, (width, height))\n",
+    "for image in images:\n",
+    "    video.write(cv2.imread(os.path.join(image_folder, image)))\n",
+    "\n",
+    "cv2.destroyAllWindows()\n",
+    "video.release()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5be9067",
+   "metadata": {},
+   "source": [
+    "# Convert video to numpy array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5e57b4ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of video array: (275, 480, 640, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def avi_to_numpy(avi_file):\n",
+    "    cap = cv2.VideoCapture(avi_file)\n",
+    "    frames = []\n",
+    "    while cap.isOpened():\n",
+    "        ret, frame = cap.read()\n",
+    "        if not ret:\n",
+    "            break\n",
+    "        frames.append(frame)\n",
+    "    cap.release()\n",
+    "\n",
+    "    return np.array(frames)\n",
+    "\n",
+    "\n",
+    "avi_file = r\"D:\\IceDyno\\IMS_Images\\2015\\2015.avi\"\n",
+    "video_array = avi_to_numpy(avi_file)\n",
+    "print(\"Shape of video array:\", video_array.shape)"
+   ]
+  }
+ ],
+ "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}