From f0fd562b27c9754ed82a9bd5552de84e3561fc21 Mon Sep 17 00:00:00 2001
From: Apaar-sc <s223141117@deakin.edu.au>
Date: Sat, 18 Apr 2026 23:26:25 +1000
Subject: [PATCH 1/5] Create Player Metirc Comparison

---
 Player_Tracking/Player Metirc Comparison | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 Player_Tracking/Player Metirc Comparison

diff --git a/Player_Tracking/Player Metirc Comparison b/Player_Tracking/Player Metirc Comparison
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/Player_Tracking/Player Metirc Comparison	
@@ -0,0 +1 @@
+

From e5076a1a0b2dd7b2a02ec6037a9baaa8a907f744 Mon Sep 17 00:00:00 2001
From: Apaar-sc <s223141117@deakin.edu.au>
Date: Sat, 18 Apr 2026 23:27:02 +1000
Subject: [PATCH 2/5] Delete Player_Tracking/Player Metirc Comparison

---
 Player_Tracking/Player Metirc Comparison | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 Player_Tracking/Player Metirc Comparison

diff --git a/Player_Tracking/Player Metirc Comparison b/Player_Tracking/Player Metirc Comparison
deleted file mode 100644
index 8b1378917..000000000
--- a/Player_Tracking/Player Metirc Comparison	
+++ /dev/null
@@ -1 +0,0 @@
-

From 14bb20be6083ace45d6b35c604cf94e5351db187 Mon Sep 17 00:00:00 2001
From: Apaar-sc <s223141117@deakin.edu.au>
Date: Sat, 18 Apr 2026 23:31:09 +1000
Subject: [PATCH 3/5] Add files via upload

---
 Metric_Comparisons.ipynb | 847 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 847 insertions(+)
 create mode 100644 Metric_Comparisons.ipynb

diff --git a/Metric_Comparisons.ipynb b/Metric_Comparisons.ipynb
new file mode 100644
index 000000000..e63349b97
--- /dev/null
+++ b/Metric_Comparisons.ipynb
@@ -0,0 +1,847 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 92
+        },
+        "id": "PyuFyfs43-qg",
+        "outputId": "44a868ee-1eed-4c51-a890-b7a3c99cae1d"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-be02d529-3280-4c94-bd56-416e715eaa92\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-be02d529-3280-4c94-bd56-416e715eaa92\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving GoldCoast_Carlton_VFL_tracking (1).json to GoldCoast_Carlton_VFL_tracking (1).json\n",
+            "Uploaded file: GoldCoast_Carlton_VFL_tracking (1).json\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()\n",
+        "\n",
+        "json_file = list(uploaded.keys())[0]\n",
+        "print(f\"Uploaded file: {json_file}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import pandas as pd\n",
+        "\n",
+        "with open(json_file, \"r\") as f:\n",
+        "    data = json.load(f)\n",
+        "\n",
+        "rows = []\n",
+        "\n",
+        "tracking_results = data.get(\"tracking_results\", [])\n",
+        "\n",
+        "for frame in tracking_results:\n",
+        "    frame_number = frame.get(\"frame_number\")\n",
+        "    timestamp = frame.get(\"timestamp\")\n",
+        "    players = frame.get(\"players\", [])\n",
+        "\n",
+        "    for player in players:\n",
+        "        bbox = player.get(\"bbox\", {})\n",
+        "        center = player.get(\"center\", {})\n",
+        "\n",
+        "        rows.append({\n",
+        "            \"frame_number\": frame_number,\n",
+        "            \"timestamp\": timestamp,\n",
+        "            \"player_id\": player.get(\"player_id\"),\n",
+        "            \"center_x\": center.get(\"x\"),\n",
+        "            \"center_y\": center.get(\"y\"),\n",
+        "            \"confidence\": player.get(\"confidence\"),\n",
+        "            \"width\": player.get(\"width\"),\n",
+        "            \"height\": player.get(\"height\"),\n",
+        "            \"bbox_x1\": bbox.get(\"x1\"),\n",
+        "            \"bbox_y1\": bbox.get(\"y1\"),\n",
+        "            \"bbox_x2\": bbox.get(\"x2\"),\n",
+        "            \"bbox_y2\": bbox.get(\"y2\")\n",
+        "        })\n",
+        "\n",
+        "df = pd.DataFrame(rows)\n",
+        "\n",
+        "print(\"Flattened tracking data:\")\n",
+        "print(df.head())\n",
+        "print(\"\\nShape:\", df.shape)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kou1gQ404ADu",
+        "outputId": "783e64c9-a4fc-40ec-eeab-a6c2314faa6c"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Flattened tracking data:\n",
+            "   frame_number  timestamp  player_id  center_x  center_y  confidence  width  \\\n",
+            "0             1      0.000          1        17       449        0.11     18   \n",
+            "1             2      0.034          1        17       449        0.12     18   \n",
+            "2             3      0.069          1        11       449        0.24     19   \n",
+            "3             5      0.138          1         4       454        0.11      8   \n",
+            "4             8      0.241          1       610       355        0.25     13   \n",
+            "\n",
+            "   height  bbox_x1  bbox_y1  bbox_x2  bbox_y2  \n",
+            "0      25        8      437       27      462  \n",
+            "1      25        8      437       27      462  \n",
+            "2      23        1      437       21      461  \n",
+            "3      24        0      441        8      466  \n",
+            "4      16      603      347      617      363  \n",
+            "\n",
+            "Shape: (21600, 12)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "flattened_csv = \"flattened_tracking_data.csv\"\n",
+        "df.to_csv(flattened_csv, index=False)\n",
+        "\n",
+        "print(f\"Saved: {flattened_csv}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "oI7y3-Hx4BBc",
+        "outputId": "00a5e15e-2c81-402a-8846-d892b918f524"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: flattened_tracking_data.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "\n",
+        "CONFIDENCE_THRESHOLD = 0.20\n",
+        "analysis_df = df[df[\"confidence\"] >= CONFIDENCE_THRESHOLD].copy()\n",
+        "\n",
+        "analysis_df = analysis_df.sort_values([\"player_id\", \"timestamp\"]).reset_index(drop=True)\n",
+        "\n",
+        "analysis_df[\"prev_x\"] = analysis_df.groupby(\"player_id\")[\"center_x\"].shift(1)\n",
+        "analysis_df[\"prev_y\"] = analysis_df.groupby(\"player_id\")[\"center_y\"].shift(1)\n",
+        "analysis_df[\"prev_t\"] = analysis_df.groupby(\"player_id\")[\"timestamp\"].shift(1)\n",
+        "\n",
+        "analysis_df[\"dx\"] = analysis_df[\"center_x\"] - analysis_df[\"prev_x\"]\n",
+        "analysis_df[\"dy\"] = analysis_df[\"center_y\"] - analysis_df[\"prev_y\"]\n",
+        "analysis_df[\"dt\"] = analysis_df[\"timestamp\"] - analysis_df[\"prev_t\"]\n",
+        "\n",
+        "analysis_df.loc[analysis_df[\"dt\"] <= 0, \"dt\"] = np.nan\n",
+        "\n",
+        "analysis_df[\"step_distance\"] = np.sqrt(analysis_df[\"dx\"]**2 + analysis_df[\"dy\"]**2)\n",
+        "\n",
+        "analysis_df[\"speed\"] = analysis_df[\"step_distance\"] / analysis_df[\"dt\"]\n",
+        "\n",
+        "analysis_df[\"prev_speed\"] = analysis_df.groupby(\"player_id\")[\"speed\"].shift(1)\n",
+        "analysis_df[\"acceleration\"] = (analysis_df[\"speed\"] - analysis_df[\"prev_speed\"]) / analysis_df[\"dt\"]\n",
+        "\n",
+        "time_visible_df = (\n",
+        "    analysis_df.groupby(\"player_id\")[\"timestamp\"]\n",
+        "    .agg([\"min\", \"max\"])\n",
+        "    .reset_index()\n",
+        ")\n",
+        "time_visible_df[\"time_visible\"] = time_visible_df[\"max\"] - time_visible_df[\"min\"]\n",
+        "time_visible_df = time_visible_df[[\"player_id\", \"time_visible\"]]\n",
+        "\n",
+        "metrics = analysis_df.groupby(\"player_id\").agg(\n",
+        "    total_distance_covered=(\"step_distance\", \"sum\"),\n",
+        "    average_speed=(\"speed\", \"mean\"),\n",
+        "    peak_speed=(\"speed\", \"max\"),\n",
+        "    average_acceleration=(\"acceleration\", \"mean\")\n",
+        ").reset_index()\n",
+        "\n",
+        "metrics = metrics.merge(time_visible_df, on=\"player_id\", how=\"left\")\n",
+        "\n",
+        "metrics = metrics.round(2)\n",
+        "\n",
+        "print(\"Tracked ID Performance Metrics\")\n",
+        "print(metrics.head(20))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WYw4pI024CSE",
+        "outputId": "7ce7094d-9605-420a-a7b1-79c0872418ce"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tracked ID Performance Metrics\n",
+            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
+            "0           1              1904710.42        2978.45    36594.90   \n",
+            "1           2               223311.81        1572.32    29411.78   \n",
+            "2           3                19948.83         833.45    16055.48   \n",
+            "3           4                 1696.87          25.16      147.90   \n",
+            "4           5                    0.00            NaN         NaN   \n",
+            "5           8                    1.00          28.57       28.57   \n",
+            "6          13                    0.00            NaN         NaN   \n",
+            "7          27                    4.47           3.82        7.63   \n",
+            "8          30                    3.00          85.71       85.71   \n",
+            "9          32                    0.00            NaN         NaN   \n",
+            "10         39                    9.64          93.33      121.22   \n",
+            "11         40                    0.00            NaN         NaN   \n",
+            "12         44                    0.00            NaN         NaN   \n",
+            "13         45                    2.83          80.81       80.81   \n",
+            "14         50                    0.00            NaN         NaN   \n",
+            "15         55                    0.00            NaN         NaN   \n",
+            "16         62                    0.00            NaN         NaN   \n",
+            "17         65                    0.00            NaN         NaN   \n",
+            "18         76                    0.00            NaN         NaN   \n",
+            "19         77                    0.00            NaN         NaN   \n",
+            "\n",
+            "    average_acceleration  time_visible  \n",
+            "0               11584.90       1752.52  \n",
+            "1               15758.34       1747.69  \n",
+            "2               18746.81       1547.79  \n",
+            "3                  10.24        892.03  \n",
+            "4                    NaN          0.00  \n",
+            "5                    NaN          0.03  \n",
+            "6                    NaN          0.00  \n",
+            "7                -218.05          0.62  \n",
+            "8                    NaN          0.04  \n",
+            "9                    NaN          0.00  \n",
+            "10               -412.46          0.10  \n",
+            "11                   NaN          0.00  \n",
+            "12                   NaN          0.00  \n",
+            "13                   NaN          0.04  \n",
+            "14                   NaN          0.00  \n",
+            "15                   NaN          0.00  \n",
+            "16                   NaN          0.00  \n",
+            "17                   NaN          0.00  \n",
+            "18                   NaN          0.00  \n",
+            "19                   NaN          0.00  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "metrics_csv = \"player_metrics_summary.csv\"\n",
+        "metrics.to_csv(metrics_csv, index=False)\n",
+        "\n",
+        "print(f\"Saved: {metrics_csv}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "76U_iPAB4EI1",
+        "outputId": "890055e4-0efe-4e74-f074-586e618a7951"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: player_metrics_summary.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "detection_counts = (\n",
+        "    analysis_df.groupby(\"player_id\")\n",
+        "    .size()\n",
+        "    .reset_index(name=\"detection_count\")\n",
+        ")\n",
+        "\n",
+        "comparison_df = metrics.merge(detection_counts, on=\"player_id\", how=\"left\")\n",
+        "\n",
+        "print(\"Comparison Table\")\n",
+        "print(comparison_df.head(20))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "awrzUCuz4EaE",
+        "outputId": "b1481eb6-5675-4fef-a99d-4e1a115ac1e1"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Comparison Table\n",
+            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
+            "0           1              1904710.42        2978.45    36594.90   \n",
+            "1           2               223311.81        1572.32    29411.78   \n",
+            "2           3                19948.83         833.45    16055.48   \n",
+            "3           4                 1696.87          25.16      147.90   \n",
+            "4           5                    0.00            NaN         NaN   \n",
+            "5           8                    1.00          28.57       28.57   \n",
+            "6          13                    0.00            NaN         NaN   \n",
+            "7          27                    4.47           3.82        7.63   \n",
+            "8          30                    3.00          85.71       85.71   \n",
+            "9          32                    0.00            NaN         NaN   \n",
+            "10         39                    9.64          93.33      121.22   \n",
+            "11         40                    0.00            NaN         NaN   \n",
+            "12         44                    0.00            NaN         NaN   \n",
+            "13         45                    2.83          80.81       80.81   \n",
+            "14         50                    0.00            NaN         NaN   \n",
+            "15         55                    0.00            NaN         NaN   \n",
+            "16         62                    0.00            NaN         NaN   \n",
+            "17         65                    0.00            NaN         NaN   \n",
+            "18         76                    0.00            NaN         NaN   \n",
+            "19         77                    0.00            NaN         NaN   \n",
+            "\n",
+            "    average_acceleration  time_visible  detection_count  \n",
+            "0               11584.90       1752.52             8180  \n",
+            "1               15758.34       1747.69              730  \n",
+            "2               18746.81       1547.79               58  \n",
+            "3                  10.24        892.03               10  \n",
+            "4                    NaN          0.00                1  \n",
+            "5                    NaN          0.03                2  \n",
+            "6                    NaN          0.00                1  \n",
+            "7                -218.05          0.62                3  \n",
+            "8                    NaN          0.04                2  \n",
+            "9                    NaN          0.00                1  \n",
+            "10               -412.46          0.10                4  \n",
+            "11                   NaN          0.00                1  \n",
+            "12                   NaN          0.00                1  \n",
+            "13                   NaN          0.04                2  \n",
+            "14                   NaN          0.00                1  \n",
+            "15                   NaN          0.00                1  \n",
+            "16                   NaN          0.00                1  \n",
+            "17                   NaN          0.00                1  \n",
+            "18                   NaN          0.00                1  \n",
+            "19                   NaN          0.00                1  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "comparison_df.to_csv(\"player_comparison_metrics.csv\", index=False)\n",
+        "print(\"Saved: player_comparison_metrics.csv\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Q_p0PSmmIrbl",
+        "outputId": "e29a653d-5f0d-4926-e456-e8618801740f"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: player_comparison_metrics.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "plot_df = comparison_df.sort_values(\"total_distance_covered\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"total_distance_covered\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Total Distance Covered\")\n",
+        "plt.title(\"Comparison of Players by Total Distance Covered\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "YNTROMDB4GC0",
+        "outputId": "3e56e662-52d0-480a-b99f-69825d356e0d"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"average_speed\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_speed\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Average Speed\")\n",
+        "plt.title(\"Comparison of Players by Average Speed\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "F1SyYrm44JDN",
+        "outputId": "1524464d-3ca1-4f30-e171-105e8b57cb03"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"peak_speed\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"peak_speed\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Peak Speed\")\n",
+        "plt.title(\"Comparison of Players by Peak Speed\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "vFOpbGI44Jys",
+        "outputId": "6edca5c5-8490-4245-e75c-2b7d459dac6d"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"average_acceleration\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_acceleration\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Average Acceleration\")\n",
+        "plt.title(\"Comparison of Players by Average Acceleration\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "DVECtr3h6JFv",
+        "outputId": "8ae48cb4-5cb6-45b2-f8d4-887453c3d4f8"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"time_visible\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"time_visible\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Time Visible (seconds)\")\n",
+        "plt.title(\"Comparison of Players by Time Visible\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "X4vdvMZj6Me9",
+        "outputId": "33f10f24-46e5-4af7-9e27-5c80adf01cb6"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "files.download(\"player_comparison_metrics.csv\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 17
+        },
+        "id": "Ze5J3FAB6Ngt",
+        "outputId": "38111e8d-3e12-47aa-8675-ecb8543a3ed6"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "\n",
+              "    async function download(id, filename, size) {\n",
+              "      if (!google.colab.kernel.accessAllowed) {\n",
+              "        return;\n",
+              "      }\n",
+              "      const div = document.createElement('div');\n",
+              "      const label = document.createElement('label');\n",
+              "      label.textContent = `Downloading \"${filename}\": `;\n",
+              "      div.appendChild(label);\n",
+              "      const progress = document.createElement('progress');\n",
+              "      progress.max = size;\n",
+              "      div.appendChild(progress);\n",
+              "      document.body.appendChild(div);\n",
+              "\n",
+              "      const buffers = [];\n",
+              "      let downloaded = 0;\n",
+              "\n",
+              "      const channel = await google.colab.kernel.comms.open(id);\n",
+              "      // Send a message to notify the kernel that we're ready.\n",
+              "      channel.send({})\n",
+              "\n",
+              "      for await (const message of channel.messages) {\n",
+              "        // Send a message to notify the kernel that we're ready.\n",
+              "        channel.send({})\n",
+              "        if (message.buffers) {\n",
+              "          for (const buffer of message.buffers) {\n",
+              "            buffers.push(buffer);\n",
+              "            downloaded += buffer.byteLength;\n",
+              "            progress.value = downloaded;\n",
+              "          }\n",
+              "        }\n",
+              "      }\n",
+              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
+              "      const a = document.createElement('a');\n",
+              "      a.href = window.URL.createObjectURL(blob);\n",
+              "      a.download = filename;\n",
+              "      div.appendChild(a);\n",
+              "      a.click();\n",
+              "      div.remove();\n",
+              "    }\n",
+              "  "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "download(\"download_8b60036a-f2f1-4c7e-a4f1-d51e885999ce\", \"player_comparison_metrics.csv\", 25494)"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "m3iFfHssIwl2"
+      },
+      "execution_count": 13,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file

From 34838c15559f59a2ff75964e7b647cdaf97d850b Mon Sep 17 00:00:00 2001
From: Apaar-sc <s223141117@deakin.edu.au>
Date: Sat, 18 Apr 2026 23:31:43 +1000
Subject: [PATCH 4/5] Add files via upload

---
 Player_Tracking/Metric_Comparisons.ipynb | 847 +++++++++++++++++++++++
 1 file changed, 847 insertions(+)
 create mode 100644 Player_Tracking/Metric_Comparisons.ipynb

diff --git a/Player_Tracking/Metric_Comparisons.ipynb b/Player_Tracking/Metric_Comparisons.ipynb
new file mode 100644
index 000000000..e63349b97
--- /dev/null
+++ b/Player_Tracking/Metric_Comparisons.ipynb
@@ -0,0 +1,847 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 92
+        },
+        "id": "PyuFyfs43-qg",
+        "outputId": "44a868ee-1eed-4c51-a890-b7a3c99cae1d"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-be02d529-3280-4c94-bd56-416e715eaa92\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-be02d529-3280-4c94-bd56-416e715eaa92\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving GoldCoast_Carlton_VFL_tracking (1).json to GoldCoast_Carlton_VFL_tracking (1).json\n",
+            "Uploaded file: GoldCoast_Carlton_VFL_tracking (1).json\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()\n",
+        "\n",
+        "json_file = list(uploaded.keys())[0]\n",
+        "print(f\"Uploaded file: {json_file}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import pandas as pd\n",
+        "\n",
+        "with open(json_file, \"r\") as f:\n",
+        "    data = json.load(f)\n",
+        "\n",
+        "rows = []\n",
+        "\n",
+        "tracking_results = data.get(\"tracking_results\", [])\n",
+        "\n",
+        "for frame in tracking_results:\n",
+        "    frame_number = frame.get(\"frame_number\")\n",
+        "    timestamp = frame.get(\"timestamp\")\n",
+        "    players = frame.get(\"players\", [])\n",
+        "\n",
+        "    for player in players:\n",
+        "        bbox = player.get(\"bbox\", {})\n",
+        "        center = player.get(\"center\", {})\n",
+        "\n",
+        "        rows.append({\n",
+        "            \"frame_number\": frame_number,\n",
+        "            \"timestamp\": timestamp,\n",
+        "            \"player_id\": player.get(\"player_id\"),\n",
+        "            \"center_x\": center.get(\"x\"),\n",
+        "            \"center_y\": center.get(\"y\"),\n",
+        "            \"confidence\": player.get(\"confidence\"),\n",
+        "            \"width\": player.get(\"width\"),\n",
+        "            \"height\": player.get(\"height\"),\n",
+        "            \"bbox_x1\": bbox.get(\"x1\"),\n",
+        "            \"bbox_y1\": bbox.get(\"y1\"),\n",
+        "            \"bbox_x2\": bbox.get(\"x2\"),\n",
+        "            \"bbox_y2\": bbox.get(\"y2\")\n",
+        "        })\n",
+        "\n",
+        "df = pd.DataFrame(rows)\n",
+        "\n",
+        "print(\"Flattened tracking data:\")\n",
+        "print(df.head())\n",
+        "print(\"\\nShape:\", df.shape)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kou1gQ404ADu",
+        "outputId": "783e64c9-a4fc-40ec-eeab-a6c2314faa6c"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Flattened tracking data:\n",
+            "   frame_number  timestamp  player_id  center_x  center_y  confidence  width  \\\n",
+            "0             1      0.000          1        17       449        0.11     18   \n",
+            "1             2      0.034          1        17       449        0.12     18   \n",
+            "2             3      0.069          1        11       449        0.24     19   \n",
+            "3             5      0.138          1         4       454        0.11      8   \n",
+            "4             8      0.241          1       610       355        0.25     13   \n",
+            "\n",
+            "   height  bbox_x1  bbox_y1  bbox_x2  bbox_y2  \n",
+            "0      25        8      437       27      462  \n",
+            "1      25        8      437       27      462  \n",
+            "2      23        1      437       21      461  \n",
+            "3      24        0      441        8      466  \n",
+            "4      16      603      347      617      363  \n",
+            "\n",
+            "Shape: (21600, 12)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "flattened_csv = \"flattened_tracking_data.csv\"\n",
+        "df.to_csv(flattened_csv, index=False)\n",
+        "\n",
+        "print(f\"Saved: {flattened_csv}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "oI7y3-Hx4BBc",
+        "outputId": "00a5e15e-2c81-402a-8846-d892b918f524"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: flattened_tracking_data.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "\n",
+        "CONFIDENCE_THRESHOLD = 0.20\n",
+        "analysis_df = df[df[\"confidence\"] >= CONFIDENCE_THRESHOLD].copy()\n",
+        "\n",
+        "analysis_df = analysis_df.sort_values([\"player_id\", \"timestamp\"]).reset_index(drop=True)\n",
+        "\n",
+        "analysis_df[\"prev_x\"] = analysis_df.groupby(\"player_id\")[\"center_x\"].shift(1)\n",
+        "analysis_df[\"prev_y\"] = analysis_df.groupby(\"player_id\")[\"center_y\"].shift(1)\n",
+        "analysis_df[\"prev_t\"] = analysis_df.groupby(\"player_id\")[\"timestamp\"].shift(1)\n",
+        "\n",
+        "analysis_df[\"dx\"] = analysis_df[\"center_x\"] - analysis_df[\"prev_x\"]\n",
+        "analysis_df[\"dy\"] = analysis_df[\"center_y\"] - analysis_df[\"prev_y\"]\n",
+        "analysis_df[\"dt\"] = analysis_df[\"timestamp\"] - analysis_df[\"prev_t\"]\n",
+        "\n",
+        "analysis_df.loc[analysis_df[\"dt\"] <= 0, \"dt\"] = np.nan\n",
+        "\n",
+        "analysis_df[\"step_distance\"] = np.sqrt(analysis_df[\"dx\"]**2 + analysis_df[\"dy\"]**2)\n",
+        "\n",
+        "analysis_df[\"speed\"] = analysis_df[\"step_distance\"] / analysis_df[\"dt\"]\n",
+        "\n",
+        "analysis_df[\"prev_speed\"] = analysis_df.groupby(\"player_id\")[\"speed\"].shift(1)\n",
+        "analysis_df[\"acceleration\"] = (analysis_df[\"speed\"] - analysis_df[\"prev_speed\"]) / analysis_df[\"dt\"]\n",
+        "\n",
+        "time_visible_df = (\n",
+        "    analysis_df.groupby(\"player_id\")[\"timestamp\"]\n",
+        "    .agg([\"min\", \"max\"])\n",
+        "    .reset_index()\n",
+        ")\n",
+        "time_visible_df[\"time_visible\"] = time_visible_df[\"max\"] - time_visible_df[\"min\"]\n",
+        "time_visible_df = time_visible_df[[\"player_id\", \"time_visible\"]]\n",
+        "\n",
+        "metrics = analysis_df.groupby(\"player_id\").agg(\n",
+        "    total_distance_covered=(\"step_distance\", \"sum\"),\n",
+        "    average_speed=(\"speed\", \"mean\"),\n",
+        "    peak_speed=(\"speed\", \"max\"),\n",
+        "    average_acceleration=(\"acceleration\", \"mean\")\n",
+        ").reset_index()\n",
+        "\n",
+        "metrics = metrics.merge(time_visible_df, on=\"player_id\", how=\"left\")\n",
+        "\n",
+        "metrics = metrics.round(2)\n",
+        "\n",
+        "print(\"Tracked ID Performance Metrics\")\n",
+        "print(metrics.head(20))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WYw4pI024CSE",
+        "outputId": "7ce7094d-9605-420a-a7b1-79c0872418ce"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tracked ID Performance Metrics\n",
+            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
+            "0           1              1904710.42        2978.45    36594.90   \n",
+            "1           2               223311.81        1572.32    29411.78   \n",
+            "2           3                19948.83         833.45    16055.48   \n",
+            "3           4                 1696.87          25.16      147.90   \n",
+            "4           5                    0.00            NaN         NaN   \n",
+            "5           8                    1.00          28.57       28.57   \n",
+            "6          13                    0.00            NaN         NaN   \n",
+            "7          27                    4.47           3.82        7.63   \n",
+            "8          30                    3.00          85.71       85.71   \n",
+            "9          32                    0.00            NaN         NaN   \n",
+            "10         39                    9.64          93.33      121.22   \n",
+            "11         40                    0.00            NaN         NaN   \n",
+            "12         44                    0.00            NaN         NaN   \n",
+            "13         45                    2.83          80.81       80.81   \n",
+            "14         50                    0.00            NaN         NaN   \n",
+            "15         55                    0.00            NaN         NaN   \n",
+            "16         62                    0.00            NaN         NaN   \n",
+            "17         65                    0.00            NaN         NaN   \n",
+            "18         76                    0.00            NaN         NaN   \n",
+            "19         77                    0.00            NaN         NaN   \n",
+            "\n",
+            "    average_acceleration  time_visible  \n",
+            "0               11584.90       1752.52  \n",
+            "1               15758.34       1747.69  \n",
+            "2               18746.81       1547.79  \n",
+            "3                  10.24        892.03  \n",
+            "4                    NaN          0.00  \n",
+            "5                    NaN          0.03  \n",
+            "6                    NaN          0.00  \n",
+            "7                -218.05          0.62  \n",
+            "8                    NaN          0.04  \n",
+            "9                    NaN          0.00  \n",
+            "10               -412.46          0.10  \n",
+            "11                   NaN          0.00  \n",
+            "12                   NaN          0.00  \n",
+            "13                   NaN          0.04  \n",
+            "14                   NaN          0.00  \n",
+            "15                   NaN          0.00  \n",
+            "16                   NaN          0.00  \n",
+            "17                   NaN          0.00  \n",
+            "18                   NaN          0.00  \n",
+            "19                   NaN          0.00  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "metrics_csv = \"player_metrics_summary.csv\"\n",
+        "metrics.to_csv(metrics_csv, index=False)\n",
+        "\n",
+        "print(f\"Saved: {metrics_csv}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "76U_iPAB4EI1",
+        "outputId": "890055e4-0efe-4e74-f074-586e618a7951"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: player_metrics_summary.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "detection_counts = (\n",
+        "    analysis_df.groupby(\"player_id\")\n",
+        "    .size()\n",
+        "    .reset_index(name=\"detection_count\")\n",
+        ")\n",
+        "\n",
+        "comparison_df = metrics.merge(detection_counts, on=\"player_id\", how=\"left\")\n",
+        "\n",
+        "print(\"Comparison Table\")\n",
+        "print(comparison_df.head(20))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "awrzUCuz4EaE",
+        "outputId": "b1481eb6-5675-4fef-a99d-4e1a115ac1e1"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Comparison Table\n",
+            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
+            "0           1              1904710.42        2978.45    36594.90   \n",
+            "1           2               223311.81        1572.32    29411.78   \n",
+            "2           3                19948.83         833.45    16055.48   \n",
+            "3           4                 1696.87          25.16      147.90   \n",
+            "4           5                    0.00            NaN         NaN   \n",
+            "5           8                    1.00          28.57       28.57   \n",
+            "6          13                    0.00            NaN         NaN   \n",
+            "7          27                    4.47           3.82        7.63   \n",
+            "8          30                    3.00          85.71       85.71   \n",
+            "9          32                    0.00            NaN         NaN   \n",
+            "10         39                    9.64          93.33      121.22   \n",
+            "11         40                    0.00            NaN         NaN   \n",
+            "12         44                    0.00            NaN         NaN   \n",
+            "13         45                    2.83          80.81       80.81   \n",
+            "14         50                    0.00            NaN         NaN   \n",
+            "15         55                    0.00            NaN         NaN   \n",
+            "16         62                    0.00            NaN         NaN   \n",
+            "17         65                    0.00            NaN         NaN   \n",
+            "18         76                    0.00            NaN         NaN   \n",
+            "19         77                    0.00            NaN         NaN   \n",
+            "\n",
+            "    average_acceleration  time_visible  detection_count  \n",
+            "0               11584.90       1752.52             8180  \n",
+            "1               15758.34       1747.69              730  \n",
+            "2               18746.81       1547.79               58  \n",
+            "3                  10.24        892.03               10  \n",
+            "4                    NaN          0.00                1  \n",
+            "5                    NaN          0.03                2  \n",
+            "6                    NaN          0.00                1  \n",
+            "7                -218.05          0.62                3  \n",
+            "8                    NaN          0.04                2  \n",
+            "9                    NaN          0.00                1  \n",
+            "10               -412.46          0.10                4  \n",
+            "11                   NaN          0.00                1  \n",
+            "12                   NaN          0.00                1  \n",
+            "13                   NaN          0.04                2  \n",
+            "14                   NaN          0.00                1  \n",
+            "15                   NaN          0.00                1  \n",
+            "16                   NaN          0.00                1  \n",
+            "17                   NaN          0.00                1  \n",
+            "18                   NaN          0.00                1  \n",
+            "19                   NaN          0.00                1  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "comparison_df.to_csv(\"player_comparison_metrics.csv\", index=False)\n",
+        "print(\"Saved: player_comparison_metrics.csv\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Q_p0PSmmIrbl",
+        "outputId": "e29a653d-5f0d-4926-e456-e8618801740f"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: player_comparison_metrics.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "plot_df = comparison_df.sort_values(\"total_distance_covered\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"total_distance_covered\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Total Distance Covered\")\n",
+        "plt.title(\"Comparison of Players by Total Distance Covered\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "YNTROMDB4GC0",
+        "outputId": "3e56e662-52d0-480a-b99f-69825d356e0d"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"average_speed\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_speed\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Average Speed\")\n",
+        "plt.title(\"Comparison of Players by Average Speed\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "F1SyYrm44JDN",
+        "outputId": "1524464d-3ca1-4f30-e171-105e8b57cb03"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"peak_speed\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"peak_speed\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Peak Speed\")\n",
+        "plt.title(\"Comparison of Players by Peak Speed\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "vFOpbGI44Jys",
+        "outputId": "6edca5c5-8490-4245-e75c-2b7d459dac6d"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"average_acceleration\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_acceleration\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Average Acceleration\")\n",
+        "plt.title(\"Comparison of Players by Average Acceleration\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "DVECtr3h6JFv",
+        "outputId": "8ae48cb4-5cb6-45b2-f8d4-887453c3d4f8"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_df = comparison_df.sort_values(\"time_visible\", ascending=False).head(10)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"time_visible\"])\n",
+        "plt.xlabel(\"Player ID\")\n",
+        "plt.ylabel(\"Time Visible (seconds)\")\n",
+        "plt.title(\"Comparison of Players by Time Visible\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 507
+        },
+        "id": "X4vdvMZj6Me9",
+        "outputId": "33f10f24-46e5-4af7-9e27-5c80adf01cb6"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "files.download(\"player_comparison_metrics.csv\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 17
+        },
+        "id": "Ze5J3FAB6Ngt",
+        "outputId": "38111e8d-3e12-47aa-8675-ecb8543a3ed6"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "\n",
+              "    async function download(id, filename, size) {\n",
+              "      if (!google.colab.kernel.accessAllowed) {\n",
+              "        return;\n",
+              "      }\n",
+              "      const div = document.createElement('div');\n",
+              "      const label = document.createElement('label');\n",
+              "      label.textContent = `Downloading \"${filename}\": `;\n",
+              "      div.appendChild(label);\n",
+              "      const progress = document.createElement('progress');\n",
+              "      progress.max = size;\n",
+              "      div.appendChild(progress);\n",
+              "      document.body.appendChild(div);\n",
+              "\n",
+              "      const buffers = [];\n",
+              "      let downloaded = 0;\n",
+              "\n",
+              "      const channel = await google.colab.kernel.comms.open(id);\n",
+              "      // Send a message to notify the kernel that we're ready.\n",
+              "      channel.send({})\n",
+              "\n",
+              "      for await (const message of channel.messages) {\n",
+              "        // Send a message to notify the kernel that we're ready.\n",
+              "        channel.send({})\n",
+              "        if (message.buffers) {\n",
+              "          for (const buffer of message.buffers) {\n",
+              "            buffers.push(buffer);\n",
+              "            downloaded += buffer.byteLength;\n",
+              "            progress.value = downloaded;\n",
+              "          }\n",
+              "        }\n",
+              "      }\n",
+              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
+              "      const a = document.createElement('a');\n",
+              "      a.href = window.URL.createObjectURL(blob);\n",
+              "      a.download = filename;\n",
+              "      div.appendChild(a);\n",
+              "      a.click();\n",
+              "      div.remove();\n",
+              "    }\n",
+              "  "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "download(\"download_8b60036a-f2f1-4c7e-a4f1-d51e885999ce\", \"player_comparison_metrics.csv\", 25494)"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "m3iFfHssIwl2"
+      },
+      "execution_count": 13,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file

From 235fef2dc2a322eb4f3486186713cc20c82c7528 Mon Sep 17 00:00:00 2001
From: Apaar-sc <s223141117@deakin.edu.au>
Date: Sat, 18 Apr 2026 23:32:09 +1000
Subject: [PATCH 5/5] Delete Metric_Comparisons.ipynb

---
 Metric_Comparisons.ipynb | 847 ---------------------------------------
 1 file changed, 847 deletions(-)
 delete mode 100644 Metric_Comparisons.ipynb

diff --git a/Metric_Comparisons.ipynb b/Metric_Comparisons.ipynb
deleted file mode 100644
index e63349b97..000000000
--- a/Metric_Comparisons.ipynb
+++ /dev/null
@@ -1,847 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 92
-        },
-        "id": "PyuFyfs43-qg",
-        "outputId": "44a868ee-1eed-4c51-a890-b7a3c99cae1d"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<IPython.core.display.HTML object>"
-            ],
-            "text/html": [
-              "\n",
-              "     <input type=\"file\" id=\"files-be02d529-3280-4c94-bd56-416e715eaa92\" name=\"files[]\" multiple disabled\n",
-              "        style=\"border:none\" />\n",
-              "     <output id=\"result-be02d529-3280-4c94-bd56-416e715eaa92\">\n",
-              "      Upload widget is only available when the cell has been executed in the\n",
-              "      current browser session. Please rerun this cell to enable.\n",
-              "      </output>\n",
-              "      <script>// Copyright 2017 Google LLC\n",
-              "//\n",
-              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
-              "// you may not use this file except in compliance with the License.\n",
-              "// You may obtain a copy of the License at\n",
-              "//\n",
-              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
-              "//\n",
-              "// Unless required by applicable law or agreed to in writing, software\n",
-              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
-              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
-              "// See the License for the specific language governing permissions and\n",
-              "// limitations under the License.\n",
-              "\n",
-              "/**\n",
-              " * @fileoverview Helpers for google.colab Python module.\n",
-              " */\n",
-              "(function(scope) {\n",
-              "function span(text, styleAttributes = {}) {\n",
-              "  const element = document.createElement('span');\n",
-              "  element.textContent = text;\n",
-              "  for (const key of Object.keys(styleAttributes)) {\n",
-              "    element.style[key] = styleAttributes[key];\n",
-              "  }\n",
-              "  return element;\n",
-              "}\n",
-              "\n",
-              "// Max number of bytes which will be uploaded at a time.\n",
-              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
-              "\n",
-              "function _uploadFiles(inputId, outputId) {\n",
-              "  const steps = uploadFilesStep(inputId, outputId);\n",
-              "  const outputElement = document.getElementById(outputId);\n",
-              "  // Cache steps on the outputElement to make it available for the next call\n",
-              "  // to uploadFilesContinue from Python.\n",
-              "  outputElement.steps = steps;\n",
-              "\n",
-              "  return _uploadFilesContinue(outputId);\n",
-              "}\n",
-              "\n",
-              "// This is roughly an async generator (not supported in the browser yet),\n",
-              "// where there are multiple asynchronous steps and the Python side is going\n",
-              "// to poll for completion of each step.\n",
-              "// This uses a Promise to block the python side on completion of each step,\n",
-              "// then passes the result of the previous step as the input to the next step.\n",
-              "function _uploadFilesContinue(outputId) {\n",
-              "  const outputElement = document.getElementById(outputId);\n",
-              "  const steps = outputElement.steps;\n",
-              "\n",
-              "  const next = steps.next(outputElement.lastPromiseValue);\n",
-              "  return Promise.resolve(next.value.promise).then((value) => {\n",
-              "    // Cache the last promise value to make it available to the next\n",
-              "    // step of the generator.\n",
-              "    outputElement.lastPromiseValue = value;\n",
-              "    return next.value.response;\n",
-              "  });\n",
-              "}\n",
-              "\n",
-              "/**\n",
-              " * Generator function which is called between each async step of the upload\n",
-              " * process.\n",
-              " * @param {string} inputId Element ID of the input file picker element.\n",
-              " * @param {string} outputId Element ID of the output display.\n",
-              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
-              " */\n",
-              "function* uploadFilesStep(inputId, outputId) {\n",
-              "  const inputElement = document.getElementById(inputId);\n",
-              "  inputElement.disabled = false;\n",
-              "\n",
-              "  const outputElement = document.getElementById(outputId);\n",
-              "  outputElement.innerHTML = '';\n",
-              "\n",
-              "  const pickedPromise = new Promise((resolve) => {\n",
-              "    inputElement.addEventListener('change', (e) => {\n",
-              "      resolve(e.target.files);\n",
-              "    });\n",
-              "  });\n",
-              "\n",
-              "  const cancel = document.createElement('button');\n",
-              "  inputElement.parentElement.appendChild(cancel);\n",
-              "  cancel.textContent = 'Cancel upload';\n",
-              "  const cancelPromise = new Promise((resolve) => {\n",
-              "    cancel.onclick = () => {\n",
-              "      resolve(null);\n",
-              "    };\n",
-              "  });\n",
-              "\n",
-              "  // Wait for the user to pick the files.\n",
-              "  const files = yield {\n",
-              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
-              "    response: {\n",
-              "      action: 'starting',\n",
-              "    }\n",
-              "  };\n",
-              "\n",
-              "  cancel.remove();\n",
-              "\n",
-              "  // Disable the input element since further picks are not allowed.\n",
-              "  inputElement.disabled = true;\n",
-              "\n",
-              "  if (!files) {\n",
-              "    return {\n",
-              "      response: {\n",
-              "        action: 'complete',\n",
-              "      }\n",
-              "    };\n",
-              "  }\n",
-              "\n",
-              "  for (const file of files) {\n",
-              "    const li = document.createElement('li');\n",
-              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
-              "    li.append(span(\n",
-              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
-              "        `last modified: ${\n",
-              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
-              "                                    'n/a'} - `));\n",
-              "    const percent = span('0% done');\n",
-              "    li.appendChild(percent);\n",
-              "\n",
-              "    outputElement.appendChild(li);\n",
-              "\n",
-              "    const fileDataPromise = new Promise((resolve) => {\n",
-              "      const reader = new FileReader();\n",
-              "      reader.onload = (e) => {\n",
-              "        resolve(e.target.result);\n",
-              "      };\n",
-              "      reader.readAsArrayBuffer(file);\n",
-              "    });\n",
-              "    // Wait for the data to be ready.\n",
-              "    let fileData = yield {\n",
-              "      promise: fileDataPromise,\n",
-              "      response: {\n",
-              "        action: 'continue',\n",
-              "      }\n",
-              "    };\n",
-              "\n",
-              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
-              "    let position = 0;\n",
-              "    do {\n",
-              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
-              "      const chunk = new Uint8Array(fileData, position, length);\n",
-              "      position += length;\n",
-              "\n",
-              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
-              "      yield {\n",
-              "        response: {\n",
-              "          action: 'append',\n",
-              "          file: file.name,\n",
-              "          data: base64,\n",
-              "        },\n",
-              "      };\n",
-              "\n",
-              "      let percentDone = fileData.byteLength === 0 ?\n",
-              "          100 :\n",
-              "          Math.round((position / fileData.byteLength) * 100);\n",
-              "      percent.textContent = `${percentDone}% done`;\n",
-              "\n",
-              "    } while (position < fileData.byteLength);\n",
-              "  }\n",
-              "\n",
-              "  // All done.\n",
-              "  yield {\n",
-              "    response: {\n",
-              "      action: 'complete',\n",
-              "    }\n",
-              "  };\n",
-              "}\n",
-              "\n",
-              "scope.google = scope.google || {};\n",
-              "scope.google.colab = scope.google.colab || {};\n",
-              "scope.google.colab._files = {\n",
-              "  _uploadFiles,\n",
-              "  _uploadFilesContinue,\n",
-              "};\n",
-              "})(self);\n",
-              "</script> "
-            ]
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Saving GoldCoast_Carlton_VFL_tracking (1).json to GoldCoast_Carlton_VFL_tracking (1).json\n",
-            "Uploaded file: GoldCoast_Carlton_VFL_tracking (1).json\n"
-          ]
-        }
-      ],
-      "source": [
-        "from google.colab import files\n",
-        "uploaded = files.upload()\n",
-        "\n",
-        "json_file = list(uploaded.keys())[0]\n",
-        "print(f\"Uploaded file: {json_file}\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "import json\n",
-        "import pandas as pd\n",
-        "\n",
-        "with open(json_file, \"r\") as f:\n",
-        "    data = json.load(f)\n",
-        "\n",
-        "rows = []\n",
-        "\n",
-        "tracking_results = data.get(\"tracking_results\", [])\n",
-        "\n",
-        "for frame in tracking_results:\n",
-        "    frame_number = frame.get(\"frame_number\")\n",
-        "    timestamp = frame.get(\"timestamp\")\n",
-        "    players = frame.get(\"players\", [])\n",
-        "\n",
-        "    for player in players:\n",
-        "        bbox = player.get(\"bbox\", {})\n",
-        "        center = player.get(\"center\", {})\n",
-        "\n",
-        "        rows.append({\n",
-        "            \"frame_number\": frame_number,\n",
-        "            \"timestamp\": timestamp,\n",
-        "            \"player_id\": player.get(\"player_id\"),\n",
-        "            \"center_x\": center.get(\"x\"),\n",
-        "            \"center_y\": center.get(\"y\"),\n",
-        "            \"confidence\": player.get(\"confidence\"),\n",
-        "            \"width\": player.get(\"width\"),\n",
-        "            \"height\": player.get(\"height\"),\n",
-        "            \"bbox_x1\": bbox.get(\"x1\"),\n",
-        "            \"bbox_y1\": bbox.get(\"y1\"),\n",
-        "            \"bbox_x2\": bbox.get(\"x2\"),\n",
-        "            \"bbox_y2\": bbox.get(\"y2\")\n",
-        "        })\n",
-        "\n",
-        "df = pd.DataFrame(rows)\n",
-        "\n",
-        "print(\"Flattened tracking data:\")\n",
-        "print(df.head())\n",
-        "print(\"\\nShape:\", df.shape)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "kou1gQ404ADu",
-        "outputId": "783e64c9-a4fc-40ec-eeab-a6c2314faa6c"
-      },
-      "execution_count": 2,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Flattened tracking data:\n",
-            "   frame_number  timestamp  player_id  center_x  center_y  confidence  width  \\\n",
-            "0             1      0.000          1        17       449        0.11     18   \n",
-            "1             2      0.034          1        17       449        0.12     18   \n",
-            "2             3      0.069          1        11       449        0.24     19   \n",
-            "3             5      0.138          1         4       454        0.11      8   \n",
-            "4             8      0.241          1       610       355        0.25     13   \n",
-            "\n",
-            "   height  bbox_x1  bbox_y1  bbox_x2  bbox_y2  \n",
-            "0      25        8      437       27      462  \n",
-            "1      25        8      437       27      462  \n",
-            "2      23        1      437       21      461  \n",
-            "3      24        0      441        8      466  \n",
-            "4      16      603      347      617      363  \n",
-            "\n",
-            "Shape: (21600, 12)\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "flattened_csv = \"flattened_tracking_data.csv\"\n",
-        "df.to_csv(flattened_csv, index=False)\n",
-        "\n",
-        "print(f\"Saved: {flattened_csv}\")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "oI7y3-Hx4BBc",
-        "outputId": "00a5e15e-2c81-402a-8846-d892b918f524"
-      },
-      "execution_count": 3,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Saved: flattened_tracking_data.csv\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "import pandas as pd\n",
-        "import numpy as np\n",
-        "\n",
-        "CONFIDENCE_THRESHOLD = 0.20\n",
-        "analysis_df = df[df[\"confidence\"] >= CONFIDENCE_THRESHOLD].copy()\n",
-        "\n",
-        "analysis_df = analysis_df.sort_values([\"player_id\", \"timestamp\"]).reset_index(drop=True)\n",
-        "\n",
-        "analysis_df[\"prev_x\"] = analysis_df.groupby(\"player_id\")[\"center_x\"].shift(1)\n",
-        "analysis_df[\"prev_y\"] = analysis_df.groupby(\"player_id\")[\"center_y\"].shift(1)\n",
-        "analysis_df[\"prev_t\"] = analysis_df.groupby(\"player_id\")[\"timestamp\"].shift(1)\n",
-        "\n",
-        "analysis_df[\"dx\"] = analysis_df[\"center_x\"] - analysis_df[\"prev_x\"]\n",
-        "analysis_df[\"dy\"] = analysis_df[\"center_y\"] - analysis_df[\"prev_y\"]\n",
-        "analysis_df[\"dt\"] = analysis_df[\"timestamp\"] - analysis_df[\"prev_t\"]\n",
-        "\n",
-        "analysis_df.loc[analysis_df[\"dt\"] <= 0, \"dt\"] = np.nan\n",
-        "\n",
-        "analysis_df[\"step_distance\"] = np.sqrt(analysis_df[\"dx\"]**2 + analysis_df[\"dy\"]**2)\n",
-        "\n",
-        "analysis_df[\"speed\"] = analysis_df[\"step_distance\"] / analysis_df[\"dt\"]\n",
-        "\n",
-        "analysis_df[\"prev_speed\"] = analysis_df.groupby(\"player_id\")[\"speed\"].shift(1)\n",
-        "analysis_df[\"acceleration\"] = (analysis_df[\"speed\"] - analysis_df[\"prev_speed\"]) / analysis_df[\"dt\"]\n",
-        "\n",
-        "time_visible_df = (\n",
-        "    analysis_df.groupby(\"player_id\")[\"timestamp\"]\n",
-        "    .agg([\"min\", \"max\"])\n",
-        "    .reset_index()\n",
-        ")\n",
-        "time_visible_df[\"time_visible\"] = time_visible_df[\"max\"] - time_visible_df[\"min\"]\n",
-        "time_visible_df = time_visible_df[[\"player_id\", \"time_visible\"]]\n",
-        "\n",
-        "metrics = analysis_df.groupby(\"player_id\").agg(\n",
-        "    total_distance_covered=(\"step_distance\", \"sum\"),\n",
-        "    average_speed=(\"speed\", \"mean\"),\n",
-        "    peak_speed=(\"speed\", \"max\"),\n",
-        "    average_acceleration=(\"acceleration\", \"mean\")\n",
-        ").reset_index()\n",
-        "\n",
-        "metrics = metrics.merge(time_visible_df, on=\"player_id\", how=\"left\")\n",
-        "\n",
-        "metrics = metrics.round(2)\n",
-        "\n",
-        "print(\"Tracked ID Performance Metrics\")\n",
-        "print(metrics.head(20))"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "WYw4pI024CSE",
-        "outputId": "7ce7094d-9605-420a-a7b1-79c0872418ce"
-      },
-      "execution_count": 4,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Tracked ID Performance Metrics\n",
-            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
-            "0           1              1904710.42        2978.45    36594.90   \n",
-            "1           2               223311.81        1572.32    29411.78   \n",
-            "2           3                19948.83         833.45    16055.48   \n",
-            "3           4                 1696.87          25.16      147.90   \n",
-            "4           5                    0.00            NaN         NaN   \n",
-            "5           8                    1.00          28.57       28.57   \n",
-            "6          13                    0.00            NaN         NaN   \n",
-            "7          27                    4.47           3.82        7.63   \n",
-            "8          30                    3.00          85.71       85.71   \n",
-            "9          32                    0.00            NaN         NaN   \n",
-            "10         39                    9.64          93.33      121.22   \n",
-            "11         40                    0.00            NaN         NaN   \n",
-            "12         44                    0.00            NaN         NaN   \n",
-            "13         45                    2.83          80.81       80.81   \n",
-            "14         50                    0.00            NaN         NaN   \n",
-            "15         55                    0.00            NaN         NaN   \n",
-            "16         62                    0.00            NaN         NaN   \n",
-            "17         65                    0.00            NaN         NaN   \n",
-            "18         76                    0.00            NaN         NaN   \n",
-            "19         77                    0.00            NaN         NaN   \n",
-            "\n",
-            "    average_acceleration  time_visible  \n",
-            "0               11584.90       1752.52  \n",
-            "1               15758.34       1747.69  \n",
-            "2               18746.81       1547.79  \n",
-            "3                  10.24        892.03  \n",
-            "4                    NaN          0.00  \n",
-            "5                    NaN          0.03  \n",
-            "6                    NaN          0.00  \n",
-            "7                -218.05          0.62  \n",
-            "8                    NaN          0.04  \n",
-            "9                    NaN          0.00  \n",
-            "10               -412.46          0.10  \n",
-            "11                   NaN          0.00  \n",
-            "12                   NaN          0.00  \n",
-            "13                   NaN          0.04  \n",
-            "14                   NaN          0.00  \n",
-            "15                   NaN          0.00  \n",
-            "16                   NaN          0.00  \n",
-            "17                   NaN          0.00  \n",
-            "18                   NaN          0.00  \n",
-            "19                   NaN          0.00  \n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "metrics_csv = \"player_metrics_summary.csv\"\n",
-        "metrics.to_csv(metrics_csv, index=False)\n",
-        "\n",
-        "print(f\"Saved: {metrics_csv}\")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "76U_iPAB4EI1",
-        "outputId": "890055e4-0efe-4e74-f074-586e618a7951"
-      },
-      "execution_count": 5,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Saved: player_metrics_summary.csv\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "detection_counts = (\n",
-        "    analysis_df.groupby(\"player_id\")\n",
-        "    .size()\n",
-        "    .reset_index(name=\"detection_count\")\n",
-        ")\n",
-        "\n",
-        "comparison_df = metrics.merge(detection_counts, on=\"player_id\", how=\"left\")\n",
-        "\n",
-        "print(\"Comparison Table\")\n",
-        "print(comparison_df.head(20))"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "awrzUCuz4EaE",
-        "outputId": "b1481eb6-5675-4fef-a99d-4e1a115ac1e1"
-      },
-      "execution_count": 6,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Comparison Table\n",
-            "    player_id  total_distance_covered  average_speed  peak_speed  \\\n",
-            "0           1              1904710.42        2978.45    36594.90   \n",
-            "1           2               223311.81        1572.32    29411.78   \n",
-            "2           3                19948.83         833.45    16055.48   \n",
-            "3           4                 1696.87          25.16      147.90   \n",
-            "4           5                    0.00            NaN         NaN   \n",
-            "5           8                    1.00          28.57       28.57   \n",
-            "6          13                    0.00            NaN         NaN   \n",
-            "7          27                    4.47           3.82        7.63   \n",
-            "8          30                    3.00          85.71       85.71   \n",
-            "9          32                    0.00            NaN         NaN   \n",
-            "10         39                    9.64          93.33      121.22   \n",
-            "11         40                    0.00            NaN         NaN   \n",
-            "12         44                    0.00            NaN         NaN   \n",
-            "13         45                    2.83          80.81       80.81   \n",
-            "14         50                    0.00            NaN         NaN   \n",
-            "15         55                    0.00            NaN         NaN   \n",
-            "16         62                    0.00            NaN         NaN   \n",
-            "17         65                    0.00            NaN         NaN   \n",
-            "18         76                    0.00            NaN         NaN   \n",
-            "19         77                    0.00            NaN         NaN   \n",
-            "\n",
-            "    average_acceleration  time_visible  detection_count  \n",
-            "0               11584.90       1752.52             8180  \n",
-            "1               15758.34       1747.69              730  \n",
-            "2               18746.81       1547.79               58  \n",
-            "3                  10.24        892.03               10  \n",
-            "4                    NaN          0.00                1  \n",
-            "5                    NaN          0.03                2  \n",
-            "6                    NaN          0.00                1  \n",
-            "7                -218.05          0.62                3  \n",
-            "8                    NaN          0.04                2  \n",
-            "9                    NaN          0.00                1  \n",
-            "10               -412.46          0.10                4  \n",
-            "11                   NaN          0.00                1  \n",
-            "12                   NaN          0.00                1  \n",
-            "13                   NaN          0.04                2  \n",
-            "14                   NaN          0.00                1  \n",
-            "15                   NaN          0.00                1  \n",
-            "16                   NaN          0.00                1  \n",
-            "17                   NaN          0.00                1  \n",
-            "18                   NaN          0.00                1  \n",
-            "19                   NaN          0.00                1  \n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "comparison_df.to_csv(\"player_comparison_metrics.csv\", index=False)\n",
-        "print(\"Saved: player_comparison_metrics.csv\")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Q_p0PSmmIrbl",
-        "outputId": "e29a653d-5f0d-4926-e456-e8618801740f"
-      },
-      "execution_count": 7,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Saved: player_comparison_metrics.csv\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "plot_df = comparison_df.sort_values(\"total_distance_covered\", ascending=False).head(10)\n",
-        "\n",
-        "plt.figure(figsize=(10, 5))\n",
-        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"total_distance_covered\"])\n",
-        "plt.xlabel(\"Player ID\")\n",
-        "plt.ylabel(\"Total Distance Covered\")\n",
-        "plt.title(\"Comparison of Players by Total Distance Covered\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 507
-        },
-        "id": "YNTROMDB4GC0",
-        "outputId": "3e56e662-52d0-480a-b99f-69825d356e0d"
-      },
-      "execution_count": 8,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "plot_df = comparison_df.sort_values(\"average_speed\", ascending=False).head(10)\n",
-        "\n",
-        "plt.figure(figsize=(10, 5))\n",
-        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_speed\"])\n",
-        "plt.xlabel(\"Player ID\")\n",
-        "plt.ylabel(\"Average Speed\")\n",
-        "plt.title(\"Comparison of Players by Average Speed\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 507
-        },
-        "id": "F1SyYrm44JDN",
-        "outputId": "1524464d-3ca1-4f30-e171-105e8b57cb03"
-      },
-      "execution_count": 9,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "plot_df = comparison_df.sort_values(\"peak_speed\", ascending=False).head(10)\n",
-        "\n",
-        "plt.figure(figsize=(10, 5))\n",
-        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"peak_speed\"])\n",
-        "plt.xlabel(\"Player ID\")\n",
-        "plt.ylabel(\"Peak Speed\")\n",
-        "plt.title(\"Comparison of Players by Peak Speed\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 507
-        },
-        "id": "vFOpbGI44Jys",
-        "outputId": "6edca5c5-8490-4245-e75c-2b7d459dac6d"
-      },
-      "execution_count": 10,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "plot_df = comparison_df.sort_values(\"average_acceleration\", ascending=False).head(10)\n",
-        "\n",
-        "plt.figure(figsize=(10, 5))\n",
-        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"average_acceleration\"])\n",
-        "plt.xlabel(\"Player ID\")\n",
-        "plt.ylabel(\"Average Acceleration\")\n",
-        "plt.title(\"Comparison of Players by Average Acceleration\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 507
-        },
-        "id": "DVECtr3h6JFv",
-        "outputId": "8ae48cb4-5cb6-45b2-f8d4-887453c3d4f8"
-      },
-      "execution_count": 11,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "plot_df = comparison_df.sort_values(\"time_visible\", ascending=False).head(10)\n",
-        "\n",
-        "plt.figure(figsize=(10, 5))\n",
-        "plt.bar(plot_df[\"player_id\"].astype(str), plot_df[\"time_visible\"])\n",
-        "plt.xlabel(\"Player ID\")\n",
-        "plt.ylabel(\"Time Visible (seconds)\")\n",
-        "plt.title(\"Comparison of Players by Time Visible\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 507
-        },
-        "id": "X4vdvMZj6Me9",
-        "outputId": "33f10f24-46e5-4af7-9e27-5c80adf01cb6"
-      },
-      "execution_count": 12,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "from google.colab import files\n",
-        "files.download(\"player_comparison_metrics.csv\")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 17
-        },
-        "id": "Ze5J3FAB6Ngt",
-        "outputId": "38111e8d-3e12-47aa-8675-ecb8543a3ed6"
-      },
-      "execution_count": 13,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<IPython.core.display.Javascript object>"
-            ],
-            "application/javascript": [
-              "\n",
-              "    async function download(id, filename, size) {\n",
-              "      if (!google.colab.kernel.accessAllowed) {\n",
-              "        return;\n",
-              "      }\n",
-              "      const div = document.createElement('div');\n",
-              "      const label = document.createElement('label');\n",
-              "      label.textContent = `Downloading \"${filename}\": `;\n",
-              "      div.appendChild(label);\n",
-              "      const progress = document.createElement('progress');\n",
-              "      progress.max = size;\n",
-              "      div.appendChild(progress);\n",
-              "      document.body.appendChild(div);\n",
-              "\n",
-              "      const buffers = [];\n",
-              "      let downloaded = 0;\n",
-              "\n",
-              "      const channel = await google.colab.kernel.comms.open(id);\n",
-              "      // Send a message to notify the kernel that we're ready.\n",
-              "      channel.send({})\n",
-              "\n",
-              "      for await (const message of channel.messages) {\n",
-              "        // Send a message to notify the kernel that we're ready.\n",
-              "        channel.send({})\n",
-              "        if (message.buffers) {\n",
-              "          for (const buffer of message.buffers) {\n",
-              "            buffers.push(buffer);\n",
-              "            downloaded += buffer.byteLength;\n",
-              "            progress.value = downloaded;\n",
-              "          }\n",
-              "        }\n",
-              "      }\n",
-              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
-              "      const a = document.createElement('a');\n",
-              "      a.href = window.URL.createObjectURL(blob);\n",
-              "      a.download = filename;\n",
-              "      div.appendChild(a);\n",
-              "      a.click();\n",
-              "      div.remove();\n",
-              "    }\n",
-              "  "
-            ]
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<IPython.core.display.Javascript object>"
-            ],
-            "application/javascript": [
-              "download(\"download_8b60036a-f2f1-4c7e-a4f1-d51e885999ce\", \"player_comparison_metrics.csv\", 25494)"
-            ]
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "m3iFfHssIwl2"
-      },
-      "execution_count": 13,
-      "outputs": []
-    }
-  ]
-}
\ No newline at end of file