{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA availability: True\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import sys\n",
    "sys.path.append(os.path.abspath(\"..\"))   # one level up\n",
    "import numpy as np\n",
    "import cv2\n",
    "import open3d as o3d\n",
    "from scipy.spatial.transform import Rotation\n",
    "from utils.lidar import PointCloud\n",
    "from utils.camera import ImageData\n",
    "import utils.utils as utils\n",
    "from natsort import natsorted, index_natsorted\n",
    "import torch\n",
    "from tqdm.notebook import tqdm\n",
    "from huggingface_hub import snapshot_download\n",
    "\n",
    "################## set device based on cuda availability #################\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "print('CUDA availability: ' + str(torch.cuda.is_available()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################### Functions for matching using numpy on CPU or Pytorch on GPU ###################\n",
    "def getMatchIndsCPU(ft_ref,ft_qry,topK=20,metric='cosine'):\n",
    "    \"\"\"\n",
    "    metric: 'euclidean' or 'cosine'\n",
    "    \"\"\"\n",
    "    # dMat = cdist(ft_ref,ft_qry,metric)\n",
    "\n",
    "    ft_qry_norm = ft_qry / np.linalg.norm(ft_qry, axis=1, keepdims=True)  # Shape (M, N)\n",
    "    ft_ref_norm = ft_ref / np.linalg.norm(ft_ref, axis=1, keepdims=True)  # Shape (C, N)\n",
    "\n",
    "    # Step 2: Compute cosine similarity\n",
    "    dMat = 1 - (ft_ref_norm @ ft_qry_norm.T)\n",
    "    mInds = np.argsort(dMat,axis=0)[:topK].squeeze() # shape: K x ft_qry.shape[0]\n",
    "    return mInds, dMat\n",
    "\n",
    "\n",
    "def getMatchIndsGPU(ft_ref, ft_qry,topK=20, metric='cosine'):\n",
    "    # metric: 'euclidean' or 'cosine'\n",
    "    ft_qry_tensor = torch.Tensor(ft_qry).to(device)\n",
    "    ft_ref_tensor = torch.Tensor(ft_ref).to(device)\n",
    "\n",
    "    if metric == 'euclidean':\n",
    "        # Use torch's cdist for Euclidean distance\n",
    "        dMat = torch.cdist(ft_ref, ft_qry)\n",
    "    \n",
    "    elif metric == 'cosine':\n",
    "        # # Normalize both the query and reference tensors\n",
    "        ft_qry_norm = ft_qry_tensor / ft_qry_tensor.norm(dim=1, keepdim=True)\n",
    "        ft_ref_norm = ft_ref_tensor / ft_ref_tensor.norm(dim=1, keepdim=True)\n",
    "        # Compute cosine similarity (1 - cosine similarity for distance)\n",
    "        dMat = 1 - ft_ref_norm @ ft_qry_norm.t()\n",
    "\n",
    "    # Get the indices of the top 5 closest matches\n",
    "    mInds = torch.argsort(dMat, dim=0)[:topK].squeeze()\n",
    "    \n",
    "    return mInds, dMat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(18009, 2)\n"
     ]
    }
   ],
   "source": [
    "# User parameters\n",
    "# vpr_desc = 'boq'\n",
    "# location = 'Holmview'\n",
    "# # location = 'Cambogan'\n",
    "\n",
    "# ################ Query filenames and directories #################################\n",
    "# # qry_sequence = '20250820_130327'\n",
    "# qry_sequence = '20250812_120856'\n",
    "# # qry_sequence = '20250811_113017'\n",
    "# # qry_sequence = '20250812_122621'\n",
    "# # qry_condition = 'flooded'\n",
    "# # qry_sequence = '20250812_122339'\n",
    "# qry_condition = 'dry'\n",
    "# qry_camera_pos = 'front'\n",
    "# qry_root_directory = f\"../../Datasets/FRED/{qry_condition}/KITTI-style\"\n",
    "# qry_vpr_root = f\"../../Datasets/FRED/vpr_ftrs/{qry_condition}/KITTI-style\"\n",
    "\n",
    "vpr_desc = 'salad'\n",
    "location = 'dalby-to-brigalow'\n",
    "# location = 'Cambogan'\n",
    "\n",
    "################ Query filenames and directories #################################\n",
    "qry_sequence = '20210909_124816_v2'\n",
    "qry_condition = ''\n",
    "qry_camera_pos = 'front'\n",
    "# qry_root_directory = f\"../../Datasets/dalby/KITTI-style/{location}\"\n",
    "qry_vpr_root = f\"../../Datasets/dalby/KITTI-style/{location}/vpr_ftrs/\"\n",
    "qry_root_directory = f\"/data/FRED/{qry_condition}/KITTI-style\"\n",
    "\n",
    "if not os.path.exists(qry_root_directory):\n",
    "    snapshot_download(\n",
    "        repo_id=\"CMalone-Jupiter/FRED\",\n",
    "        repo_type=\"dataset\",\n",
    "        local_dir=\"/data/FRED\",\n",
    "        allow_patterns=f\"{qry_condition}/KITTI-style/{location}_{qry_sequence}/**\",\n",
    "        token=os.environ.get(\"HF_TOKEN\")\n",
    "    )\n",
    "\n",
    "qry_image_dir = f\"{qry_root_directory}/{qry_sequence}/{qry_camera_pos}-imgs/\"\n",
    "qry_utm_dir = f\"{qry_root_directory}/{qry_sequence}/utm/\"\n",
    "qry_utms = np.array([np.loadtxt(qry_utm_dir+filename) for filename in natsorted(os.listdir(qry_utm_dir)) if os.path.isfile(qry_utm_dir+filename)])\n",
    "qry_timestamps = [filename.split('.png')[0] for filename in natsorted(os.listdir(qry_image_dir)) if os.path.isfile(qry_image_dir+filename)]\n",
    "qry_name_sort_idx = index_natsorted(os.listdir(qry_image_dir))\n",
    "qry_ftrs = np.load(f\"{qry_vpr_root}/{qry_sequence}/{vpr_desc}/queries_descriptors.npy\")\n",
    "qry_ftrs = qry_ftrs[qry_name_sort_idx]\n",
    "\n",
    "# qry_ftrs = qry_ftrs[::2]\n",
    "# qry_timestamps = qry_timestamps[::2]\n",
    "\n",
    "\n",
    "################ Reference filenames and directories #################################\n",
    "# ref_sequence = '20250812_120100'\n",
    "# # 20250812_120856\n",
    "# # ref_sequence = '20250812_122339'\n",
    "# # 20250812_122621\n",
    "# ref_condition = 'dry'\n",
    "# ref_camera_pos = 'front'\n",
    "# ref_root_directory = f\"../../Datasets/FRED/{ref_condition}/KITTI-style\"\n",
    "# ref_vpr_root = f\"../../Datasets/FRED/vpr_ftrs/{ref_condition}/KITTI-style\"\n",
    "\n",
    "ref_sequence = '20230509_115540_v2'\n",
    "ref_condition = ''\n",
    "ref_camera_pos = 'front'\n",
    "# ref_root_directory = f\"../../Datasets/dalby/KITTI-style/{location}\"\n",
    "ref_vpr_root = f\"../../Datasets/dalby/KITTI-style/{location}/vpr_ftrs/\"\n",
    "ref_root_directory = f\"/data/FRED/{ref_condition}/KITTI-style\"\n",
    "\n",
    "if not os.path.exists(ref_root_directory):\n",
    "    snapshot_download(\n",
    "        repo_id=\"CMalone-Jupiter/FRED\",\n",
    "        repo_type=\"dataset\",\n",
    "        local_dir=\"/data/FRED\",\n",
    "        allow_patterns=f\"{ref_condition}/KITTI-style/{location}_{ref_sequence}/**\",\n",
    "        token=os.environ.get(\"HF_TOKEN\")\n",
    "    )\n",
    "\n",
    "ref_image_dir = f\"{ref_root_directory}/{ref_sequence}/{ref_camera_pos}-imgs/\"\n",
    "ref_utm_dir = f\"{ref_root_directory}/{ref_sequence}/utm/\"\n",
    "ref_timestamps = [filename.split('.png')[0] for filename in natsorted(os.listdir(ref_image_dir)) if os.path.isfile(ref_image_dir+filename)]\n",
    "ref_name_sort_idx = index_natsorted(os.listdir(ref_image_dir))\n",
    "ref_utms = np.array([np.loadtxt(ref_utm_dir+filename) for filename in natsorted(os.listdir(ref_utm_dir)) if os.path.isfile(ref_utm_dir+filename)])[55::]\n",
    "print(ref_utms.shape)\n",
    "ref_img_filenames = [filename for filename in natsorted(os.listdir(ref_image_dir)) if os.path.isfile(ref_image_dir+filename)]\n",
    "ref_utm_filenames = np.array([filename for filename in natsorted(os.listdir(ref_utm_dir)) if os.path.isfile(ref_utm_dir+filename)])[:len(os.listdir(ref_utm_dir))-55]\n",
    "ref_ftrs = np.load(f\"{ref_vpr_root}/{ref_sequence}/{vpr_desc}/queries_descriptors.npy\")\n",
    "ref_ftrs = ref_ftrs[ref_name_sort_idx]\n",
    "\n",
    "# ref_timestamps = ref_timestamps[::2]\n",
    "# ref_img_filenames = ref_img_filenames[::2]\n",
    "# ref_ftrs = ref_ftrs[::2]\n",
    "\n",
    "img_calib_file = f\"../camera_calib.txt\"\n",
    "\n",
    "dist_tolerance = 10 # metres\n",
    "# qry_idx = 4\n",
    "\n",
    "qry_utm_timestamps, qry_utm_idxs = utils.get_all_corr_files(qry_timestamps, [qry_utm_dir,])\n",
    "ref_utm_timestamp, ref_utm_idxs = utils.get_all_corr_files(ref_timestamps, [ref_utm_dir,])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fe0f5b498d8f437b9e761d3747cfddc3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/24299 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 52.49%\n",
      "Valid queries: 23438\n"
     ]
    }
   ],
   "source": [
    "mInds, dMat = getMatchIndsGPU(ref_ftrs,qry_ftrs,topK=1)\n",
    "mInds = mInds.cpu().numpy()\n",
    "in_tol = []\n",
    "dists = []\n",
    "\n",
    "valid_qry = []\n",
    "colors = []\n",
    "plot_utms = []\n",
    "\n",
    "for qry_idx in tqdm(range(len(qry_timestamps))):\n",
    "\n",
    "    qry_image_timestamp = qry_timestamps[qry_idx]\n",
    "    qry_image_filename = f\"{qry_image_dir}/{qry_image_timestamp}.png\"\n",
    "    # qry_utm_timestamp = utils.get_corr_files(qry_image_timestamp, [qry_utm_dir,])\n",
    "    qry_utm = qry_utms[qry_utm_idxs[qry_idx]]\n",
    "    # qry_utm = np.loadtxt(qry_utm_timestamp)\n",
    "\n",
    "    # print(f\"Number of queries: {len(qry_timestamps)}\")\n",
    "    # print(f\"Number of references{ {len(ref_timestamps)}}\")\n",
    "    # print(f\"Matche  {mInds[qry_idx]}\")\n",
    "    # print(natsorted(os.listdir(qry_image_dir)))\n",
    "    # print(os.listdir(qry_image_dir))\n",
    "\n",
    "    # ref_utm_timestamp = utils.get_corr_files(ref_timestamps[int(mInds[qry_idx])], [ref_utm_dir,])\n",
    "    # ref_utm = np.loadtxt(ref_utm_timestamp)\n",
    "    ref_utm = ref_utms[ref_utm_idxs[int(mInds[qry_idx])]]\n",
    "\n",
    "    diff = ref_utm - qry_utm           # shape (N, 2)\n",
    "    dist = np.linalg.norm(diff)   # shape (N,)\n",
    "    dists.append(dist)\n",
    "    if dist < dist_tolerance:\n",
    "        in_tol.append(1)\n",
    "    else:\n",
    "        in_tol.append(0)\n",
    "\n",
    "    diffs = ref_utms - qry_utm           # shape (N, 2)\n",
    "    qry_dists = np.linalg.norm(diffs, axis=1)   # shape (N,)\n",
    "    if qry_dists.min() > dist_tolerance:\n",
    "        # continue\n",
    "        valid_qry.append(0)\n",
    "    else:\n",
    "        valid_qry.append(1)\n",
    "        plot_utms.append(qry_utm)\n",
    "        if in_tol[-1]:\n",
    "            colors.append('g')\n",
    "        else:\n",
    "            colors.append('r')\n",
    "\n",
    "\n",
    "    # if qry_idx%1000 == 0:\n",
    "\n",
    "    #     fig, ax = plt.subplots(1, 2, figsize=(9.5, 3))\n",
    "    #     ax[0].clear()\n",
    "    #     ax[1].clear()\n",
    "    #     qry_image = ImageData(qry_image_filename, img_calib_file)\n",
    "\n",
    "    #     ax[0].imshow(qry_image.image[:, :, ::-1])\n",
    "    #     ax[0].set_title(f\"{qry_image_timestamp}.png\")\n",
    "    #     ax[0].axis(\"off\")\n",
    "\n",
    "    #     ref_img_timestamp = utils.get_corr_files(ref_timestamps[int(mInds[qry_idx])], [ref_image_dir,])\n",
    "\n",
    "    #     ref_image = ImageData(ref_img_timestamp, img_calib_file)\n",
    "    #     ax[1].imshow(ref_image.image[:, :, ::-1]) #cv2.flip(,1)\n",
    "    #     ax[1].set_title(f\"{ref_img_timestamp.split('/')[-1]}\\nDist={dist:.2f}m\")\n",
    "\n",
    "    # qry_image = ImageData(qry_image_filename, img_calib_file)\n",
    "\n",
    "    # fig, ax = plt.subplots(1, 2, figsize=(19.4, 6))\n",
    "    # ax[0].clear()\n",
    "    # ax[1].clear()\n",
    "\n",
    "    # ax[0].imshow(qry_image.image[:, :, ::-1])\n",
    "    # ax[0].set_title(f\"{qry_image_timestamp}.png\")\n",
    "    # ax[0].axis(\"off\")\n",
    "\n",
    "    # # Show matching reference image\n",
    "    # # ref_img_timestamp = utils.get_corr_files(ref_timestamps[int(mInds[qry_idx])], [ref_image_dir,])\n",
    "    # ref_image = ImageData(f\"{ref_image_dir}/{ref_timestamps[int(mInds[qry_idx])]}.png\", img_calib_file)\n",
    "    # ax[1].imshow(ref_image.image[:, :, ::-1])\n",
    "    # ax[1].set_title(f\"{ref_timestamps[int(mInds[qry_idx])]}\\nDist={dist:.2f}m\")\n",
    "\n",
    "    # ax[1].axis(\"off\")\n",
    "    # fig.canvas.draw()\n",
    "\n",
    "# print(f\"Recall: {np.sum(np.array(in_tol))/len(qry_timestamps):.02%}\")\n",
    "print(f\"Recall: {np.sum(np.array(in_tol))/np.sum(valid_qry):.02%}\")\n",
    "print(f\"Valid queries: {np.sum(valid_qry)}\")\n",
    "# plt.figure()\n",
    "# plt.plot(np.clip(dists, 0, 30))\n",
    "# plt.ylim((0,35))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x120f23ef5e0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import seaborn as sns\n",
    "\n",
    "# dist_data = np.clip(dists, 0, 50)\n",
    "\n",
    "# plt.figure(figsize=(38, 6))\n",
    "# plt.scatter(np.arange(len(dist_data)), dist_data)\n",
    "# plt.ylim((0,60))\n",
    "\n",
    "# fig, ax = plt.subplots(1,1) #figsize=(19, 6)\n",
    "# # sns.histplot(np.clip(dists[::6], 0, 50), kde=True, bins=30)\n",
    "# sns.kdeplot(dist_data, fill=True)\n",
    "# # plt.plot(np.clip(dists[::6], 0, 50))\n",
    "# # plt.ylim((0,60))\n",
    "# plt.xlim(0, 50)\n",
    "# plt.title('VPR Match Distance Distribution')\n",
    "# plt.xticks([0, 10, 20, 30, 40, 50], labels=['0m', '10m', '20m', '30m', '40m', '>50m'])\n",
    "# # print(np.sum(np.array(dists)>5000))\n",
    "# plt.figure(figsize=(38, 3))\n",
    "# plt.plot(valid_qry)\n",
    "# warra = [278500, 7017500]\n",
    "# macalister = [375000, 7007000]\n",
    "# brigalow = [265360, 7046313]\n",
    "dalby_utm = [326893.216, 6992729.692]\n",
    "macalister_utm = [309287.466, 7007270.149]\n",
    "warra_utm = [293685.547, 7019462.582]\n",
    "brigalow_utm = [280382.449, 7028979.359]\n",
    "\n",
    "plt.figure(figsize=(25,10))\n",
    "plt.scatter(np.array(plot_utms)[::100,0], np.array(plot_utms)[::100,1], marker='.', c=colors[::100])\n",
    "plt.scatter(warra_utm[0], warra_utm[1], marker='o', s=120, c='b')\n",
    "plt.scatter(macalister_utm[0], macalister_utm[1], marker='o', s=120, c='b')\n",
    "plt.scatter(brigalow_utm[0], brigalow_utm[1], marker='o', s=120, c='b')\n",
    "plt.scatter(dalby_utm[0], dalby_utm[1], marker='o', s=120, c='b')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "CARRSQ",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}