generate_3d_polar.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 tesseract_00003.mat processed successfully\n",
      "2 tesseract_00001.mat processed successfully\n",
      "2 tesseract_00002.mat processed successfully\n",
      "2 tesseract_00004.mat processed successfully\n",
      "2 tesseract_00005.mat processed successfully\n",
      "2 tesseract_00006.mat processed successfully\n",
      "2 tesseract_00008.mat processed successfully\n",
      "2 tesseract_00007.mat processed successfully\n",
      "2 tesseract_00009.mat processed successfully\n",
      "2 tesseract_00010.mat processed successfully\n",
      "2 tesseract_00012.mat processed successfully\n",
      "2 tesseract_00011.mat processed successfully\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
    "\n",
    "# Function to process each file within a clip\n",
    "def process_file(clip, file, input_dir, output_dir):\n",
    "    file_path = os.path.join(input_dir, file)\n",
    "    mat = scipy.io.loadmat(file_path)\n",
    "    \n",
    "    arrayREA = np.mean(mat['arrDREA'], axis=0)\n",
    "    idx = file.split(\"_\")[-1].split(\".\")[0]\n",
    "    \n",
    "    output_file_path = os.path.join(output_dir, f\"cube_{idx}.npy\")\n",
    "    np.save(output_file_path, arrayREA)\n",
    "    return f\"{clip} {file} processed successfully\"\n",
    "\n",
    "# Function to handle the processing of a single clip, parallelizing file operations\n",
    "def process_clip(clip):\n",
    "    output_dir = os.path.join(output_base_dir, clip, \"radar_polar_cube\")\n",
    "    input_dir = os.path.join(input_base_dir, clip, \"radar_tesseract\")\n",
    "\n",
    "    os.makedirs(output_dir, exist_ok=True)\n",
    "    file_names = sorted(os.listdir(input_dir))\n",
    "\n",
    "    with ThreadPoolExecutor(max_workers=36) as executor:\n",
    "        # Submitting file processing tasks for the current clip\n",
    "        future_to_file = {executor.submit(process_file, clip, file, input_dir, output_dir): file for file in file_names}\n",
    "        \n",
    "        # As each file processing completes, you can add logging or error handling here\n",
    "        for future in as_completed(future_to_file):\n",
    "            file = future_to_file[future]\n",
    "            try:\n",
    "                result = future.result()\n",
    "            except Exception as exc:\n",
    "                print(f'File {file} in clip {clip} generated an exception: {exc}')\n",
    "            else:\n",
    "                print(result)\n",
    "\n",
    "input_base_dir = \"/mnt/Kradar/K-Radar/\"\n",
    "output_base_dir = \"/mnt/12T-Data/Kradar/\"\n",
    "clips = sorted(os.listdir(input_base_dir), key=lambda x: int(x))\n",
    "\n",
    "# Processing each clip, but within each clip, files are processed in parallel\n",
    "for clip in clips:\n",
    "    if clip == '1':\n",
    "        continue\n",
    "    process_clip(clip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "data = np.load('/mnt/18T-Data/kradar/2/radar_polar_EAsparse/cube_00001.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube = torch.tensor(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/xiangyu/miniconda3/envs/OpenOccupancy/lib/python3.7/site-packages/ipykernel_launcher.py:11: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    }
   ],
   "source": [
    "cube_flat = cube.reshape(cube.shape[0], -1)\n",
    "k = 100\n",
    "# Use 'torch.topk' to get the indices of the top k elements\n",
    "top_k_values, top_k_idx = torch.topk(cube_flat, k, dim=1)\n",
    "# Create a mask with the same shape as cube_flat\n",
    "mask_flat = torch.zeros_like(cube_flat, dtype=torch.bool)\n",
    "mask_flat[torch.arange(cube_flat.shape[0])[:, None], top_k_idx] = True\n",
    "\n",
    "# Calculate the indices for the range, elevation, and azimuth\n",
    "range_inds = torch.arange(cube.shape[0])[:, None]\n",
    "elevation_inds = top_k_idx // cube.shape[2]\n",
    "azimuth_inds = top_k_idx % cube.shape[2]\n",
    "range_ind = torch.repeat_interleave(range_inds, k).flatten()\n",
    "elevation_ind = elevation_inds.flatten()\n",
    "azimuth_ind = azimuth_inds.flatten()\n",
    "# Extract the values at these indices from the original cube tensor\n",
    "power_val = cube[range_ind, elevation_ind, azimuth_ind].unsqueeze(-1)\n",
    "# thr_vale = arr_cube.quantile(quantile_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = nn.Linear(64, 64, bias=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1113, 2182, 2289,  ..., 2504, 1002, 2606],\n",
       "        [3048, 2941, 3155,  ...,  352, 1324, 3466],\n",
       "        [3048, 2941,  139,  ..., 3688,  598,  492],\n",
       "        ...,\n",
       "        [3048, 3155, 2830,  ..., 3453, 3561, 3882],\n",
       "        [3048, 3155, 2941,  ..., 1230, 3365,  357],\n",
       "        [3048, 2941, 3155,  ..., 3603, 3257, 2489]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_k_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2.1709e+16, 2.1007e+16, 2.0417e+16,  ..., 6.4997e+15, 6.4883e+15,\n",
       "         6.4773e+15],\n",
       "        [2.8041e+13, 2.5031e+13, 2.3143e+13,  ..., 8.2490e+12, 8.2200e+12,\n",
       "         8.2055e+12],\n",
       "        [6.2471e+12, 5.5846e+12, 5.2108e+12,  ..., 2.1153e+12, 2.1036e+12,\n",
       "         2.1007e+12],\n",
       "        ...,\n",
       "        [3.3195e+12, 3.2346e+12, 2.5564e+12,  ..., 9.7881e+11, 9.7858e+11,\n",
       "         9.5820e+11],\n",
       "        [6.8848e+12, 6.1828e+12, 5.6518e+12,  ..., 2.0597e+12, 2.0519e+12,\n",
       "         2.0436e+12],\n",
       "        [2.6107e+13, 2.2673e+13, 2.2203e+13,  ..., 8.2882e+12, 8.2065e+12,\n",
       "         8.1713e+12]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_k_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2.1709e+16],\n",
       "        [2.1007e+16],\n",
       "        [2.0417e+16],\n",
       "        ...,\n",
       "        [8.2882e+12],\n",
       "        [8.2065e+12],\n",
       "        [8.1713e+12]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2.1709e+16)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube[0,10,43]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2.1709e+16)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power_val.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([204800])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_ind.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([10, 20, 21,  ...,  6, 20, 19])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elevation_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([43, 42, 42,  ..., 70, 43, 32])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "azimuth_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([  0,   0,   0,  ..., 255, 255, 255])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([204800, 1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power_val.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "surroundocc",
   "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.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}