├── README.md ├── make_ShanghaiTech.ipynb └── make_ShanghaiTech.py /README.md: -------------------------------------------------------------------------------- 1 | ### Fast computing density maps for ShanghaiTech 2 | 3 | You can choose how to compute sigma : distance to 3 nearest neighbors, distance to nearest neighbor, or fixed value. Optionally clip sigma if it is lower than threshold. 4 | 5 | I've used pre-computed gaussian kernels and fast neighbors search to speed up density maps creation. 6 | -------------------------------------------------------------------------------- /make_ShanghaiTech.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import os\n", 10 | "import cv2\n", 11 | "import glob\n", 12 | "import h5py\n", 13 | "import scipy\n", 14 | "import pickle\n", 15 | "import numpy as np\n", 16 | "from PIL import Image\n", 17 | "import scipy.io as io\n", 18 | "from itertools import islice\n", 19 | "from tqdm import tqdm_notebook\n", 20 | "from matplotlib import pyplot as plt\n", 21 | "from sortedcontainers import SortedDict\n", 22 | "from scipy.ndimage.filters import gaussian_filter \n", 23 | "%matplotlib inline" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 2, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "def get_img_pathes(path_sets):\n", 33 | " \"\"\"\n", 34 | " Return all images from all pathes in 'path_sets'\n", 35 | " \"\"\"\n", 36 | " img_pathes = []\n", 37 | " for path in path_sets:\n", 38 | " for img_path in glob.glob(os.path.join(path, '*.jpg')):\n", 39 | " img_pathes.append(img_path)\n", 40 | " return img_pathes\n", 41 | "\n", 42 | "\n", 43 | "def save_computed_density(density_map, out_path):\n", 44 | " \"\"\"\n", 45 | " Save density map to h5py format\n", 46 | " \"\"\"\n", 47 | " with h5py.File(out_path, 'w') as hf:\n", 48 | " hf['density'] = density_map\n", 49 | " \n", 50 | "\n", 51 | "def compute_sigma(gt_count, distance=None, min_sigma=1, method=1, fixed_sigma=15):\n", 52 | " \"\"\"\n", 53 | " Compute sigma for gaussian kernel with different methods :\n", 54 | " * method = 1 : sigma = (sum of distance to 3 nearest neighbors) / 10\n", 55 | " * method = 2 : sigma = distance to nearest neighbor\n", 56 | " * method = 3 : sigma = fixed value\n", 57 | " ** if sigma lower than threshold 'min_sigma', then 'min_sigma' will be used\n", 58 | " ** in case of one point on the image sigma = 'fixed_sigma'\n", 59 | " \"\"\" \n", 60 | " if gt_count > 1 and distance is not None:\n", 61 | " if method == 1:\n", 62 | " sigma = np.mean(distance[1:4])*0.1\n", 63 | " elif method == 2:\n", 64 | " sigma = distance[1]\n", 65 | " elif method == 3:\n", 66 | " sigma = fixed_sigma\n", 67 | " else:\n", 68 | " sigma = fixed_sigma\n", 69 | " if sigma < min_sigma:\n", 70 | " sigma = min_sigma\n", 71 | " return sigma\n", 72 | "\n", 73 | "\n", 74 | "def find_closest_key(sorted_dict, key):\n", 75 | " \"\"\"\n", 76 | " Find closest key in sorted_dict to 'key'\n", 77 | " \"\"\"\n", 78 | " keys = list(islice(sorted_dict.irange(minimum=key), 1))\n", 79 | " keys.extend(islice(sorted_dict.irange(maximum=key, reverse=True), 1))\n", 80 | " return min(keys, key=lambda k: abs(key - k))\n", 81 | "\n", 82 | "\n", 83 | "def gaussian_filter_density(non_zero_points, map_h, map_w, distances=None, kernels_dict=None, min_sigma=2, method=1, const_sigma=15):\n", 84 | " \"\"\"\n", 85 | " Fast gaussian filter implementation : using precomputed distances and kernels\n", 86 | " \"\"\"\n", 87 | " gt_count = non_zero_points.shape[0]\n", 88 | " density_map = np.zeros((map_h, map_w), dtype=np.float32)\n", 89 | "\n", 90 | " for i in range(gt_count):\n", 91 | " point_y, point_x = non_zero_points[i]\n", 92 | " sigma = compute_sigma(gt_count, distances[i], min_sigma=min_sigma, method=method, fixed_sigma=const_sigma)\n", 93 | " closest_sigma = find_closest_key(kernels_dict, sigma)\n", 94 | " kernel = kernels_dict[closest_sigma]\n", 95 | " full_kernel_size = kernel.shape[0]\n", 96 | " kernel_size = full_kernel_size // 2\n", 97 | "\n", 98 | " min_img_x = max(0, point_x-kernel_size)\n", 99 | " min_img_y = max(0, point_y-kernel_size)\n", 100 | " max_img_x = min(point_x+kernel_size+1, map_h - 1)\n", 101 | " max_img_y = min(point_y+kernel_size+1, map_w - 1)\n", 102 | "\n", 103 | " kernel_x_min = kernel_size - point_x if point_x <= kernel_size else 0\n", 104 | " kernel_y_min = kernel_size - point_y if point_y <= kernel_size else 0\n", 105 | " kernel_x_max = kernel_x_min + max_img_x - min_img_x\n", 106 | " kernel_y_max = kernel_y_min + max_img_y - min_img_y\n", 107 | "\n", 108 | " density_map[min_img_x:max_img_x, min_img_y:max_img_y] += kernel[kernel_x_min:kernel_x_max, kernel_y_min:kernel_y_max]\n", 109 | " return density_map\n", 110 | "\n", 111 | "\n", 112 | "def get_gt_dots(mat_path, img_height, img_width):\n", 113 | " \"\"\"\n", 114 | " Load Matlab file with ground truth labels and save it to numpy array.\n", 115 | " ** cliping is needed to prevent going out of the array\n", 116 | " \"\"\"\n", 117 | " mat = io.loadmat(mat_path)\n", 118 | " gt = mat[\"image_info\"][0,0][0,0][0].astype(np.float32).round().astype(int)\n", 119 | " gt[:,0] = gt[:,0].clip(0, img_width - 1)\n", 120 | " gt[:,1] = gt[:,1].clip(0, img_height - 1)\n", 121 | " return gt\n", 122 | "\n", 123 | "\n", 124 | "def set_circles_on_img(image, bbox_list, circle_size=2):\n", 125 | " \"\"\"\n", 126 | " Set circles on images at centers of bboxes in bbox_list\n", 127 | " \"\"\"\n", 128 | " for bbox in bbox_list:\n", 129 | " cv2.circle(image, (bbox[0], bbox[1]), circle_size, (255, 0, 0), -1)\n", 130 | " return image\n", 131 | "\n", 132 | "\n", 133 | "def generate_gaussian_kernels(out_kernels_path='gaussian_kernels.pkl', round_decimals = 3, sigma_threshold = 4, sigma_min=0, sigma_max=20, num_sigmas=801):\n", 134 | " \"\"\"\n", 135 | " Computing gaussian filter kernel for sigmas in linspace(sigma_min, sigma_max, num_sigmas) and saving \n", 136 | " them to dict. \n", 137 | " \"\"\"\n", 138 | " kernels_dict = dict()\n", 139 | " sigma_space = np.linspace(sigma_min, sigma_max, num_sigmas)\n", 140 | " for sigma in tqdm_notebook(sigma_space):\n", 141 | " sigma = np.round(sigma, decimals=round_decimals) \n", 142 | " kernel_size = np.ceil(sigma*sigma_threshold).astype(np.int)\n", 143 | "\n", 144 | " img_shape = (kernel_size*2+1, kernel_size*2+1)\n", 145 | " img_center = (img_shape[0]//2, img_shape[1]//2)\n", 146 | "\n", 147 | " arr = np.zeros(img_shape)\n", 148 | " arr[img_center] = 1\n", 149 | "\n", 150 | " arr = scipy.ndimage.filters.gaussian_filter(arr, sigma, mode='constant') \n", 151 | " kernel = arr / arr.sum()\n", 152 | " kernels_dict[sigma] = kernel\n", 153 | " \n", 154 | " print(f'Computed {len(sigma_space)} gaussian kernels. Saving them to {out_kernels_path}')\n", 155 | "\n", 156 | " with open(out_kernels_path, 'wb') as f:\n", 157 | " pickle.dump(kernels_dict, f)\n", 158 | " \n", 159 | " \n", 160 | "def compute_distances(out_dist_path='distances_dict.pkl', Shanghai_root_path='./', n_neighbors = 4, leafsize=1024):\n", 161 | " distances_dict = dict()\n", 162 | " full_img_pathes = glob.glob(f'{Shanghai_root_path}*/*/images/*.jpg')\n", 163 | "\n", 164 | " for full_img_path in tqdm_notebook(full_img_pathes):\n", 165 | " mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_')\n", 166 | "\n", 167 | " img = plt.imread(full_img_path)\n", 168 | " non_zero_points = get_gt_dots(mat_path, *img.shape[0:2])\n", 169 | "\n", 170 | " tree = scipy.spatial.KDTree(non_zero_points.copy(), leafsize=leafsize) # build kdtree\n", 171 | " distances, _ = tree.query(non_zero_points, k=n_neighbors) # query kdtree\n", 172 | "\n", 173 | " distances_dict[full_img_path] = distances\n", 174 | " \n", 175 | " print(f'Distances computed for {len(full_img_pathes)}. Saving them to {out_dist_path}')\n", 176 | "\n", 177 | " with open(out_dist_path, 'wb') as f:\n", 178 | " pickle.dump(distances_dict, f)" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 3, 184 | "metadata": {}, 185 | "outputs": [ 186 | { 187 | "data": { 188 | "application/vnd.jupyter.widget-view+json": { 189 | "model_id": "a1909e43ea2345f5a914032bd00e9626", 190 | "version_major": 2, 191 | "version_minor": 0 192 | }, 193 | "text/plain": [ 194 | "HBox(children=(IntProgress(value=0, max=801), HTML(value='')))" 195 | ] 196 | }, 197 | "metadata": {}, 198 | "output_type": "display_data" 199 | }, 200 | { 201 | "name": "stdout", 202 | "output_type": "stream", 203 | "text": [ 204 | "\n", 205 | "Computed 801 gaussian kernels. Saving them to gaussian_kernels.pkl\n" 206 | ] 207 | } 208 | ], 209 | "source": [ 210 | "precomputed_kernels_path = 'gaussian_kernels.pkl'\n", 211 | "\n", 212 | "# uncomment to generate and save dict with kernel sizes\n", 213 | "generate_gaussian_kernels(precomputed_kernels_path, round_decimals=3, sigma_threshold=4, sigma_min=0, sigma_max=20, num_sigmas=801)\n", 214 | " \n", 215 | "with open(precomputed_kernels_path, 'rb') as f:\n", 216 | " kernels_dict = pickle.load(f)\n", 217 | " kernels_dict = SortedDict(kernels_dict)" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 4, 223 | "metadata": {}, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "application/vnd.jupyter.widget-view+json": { 228 | "model_id": "bb7d6ef718f4402fa478bb16eabb23c5", 229 | "version_major": 2, 230 | "version_minor": 0 231 | }, 232 | "text/plain": [ 233 | "HBox(children=(IntProgress(value=0, max=1198), HTML(value='')))" 234 | ] 235 | }, 236 | "metadata": {}, 237 | "output_type": "display_data" 238 | }, 239 | { 240 | "name": "stdout", 241 | "output_type": "stream", 242 | "text": [ 243 | "\n", 244 | "Distances computed for 1198. Saving them to distances_dict.pkl\n" 245 | ] 246 | } 247 | ], 248 | "source": [ 249 | "precomputed_distances_path = 'distances_dict.pkl'\n", 250 | "\n", 251 | "# uncomment to generate and save dict with distances \n", 252 | "compute_distances(out_dist_path=precomputed_distances_path, Shanghai_root_path='/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/')\n", 253 | " \n", 254 | "with open(precomputed_distances_path, 'rb') as f:\n", 255 | " distances_dict = pickle.load(f)" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 5, 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "data": { 265 | "application/vnd.jupyter.widget-view+json": { 266 | "model_id": "6b9af7f918e140e0a8b931c65e841c32", 267 | "version_major": 2, 268 | "version_minor": 0 269 | }, 270 | "text/plain": [ 271 | "HBox(children=(IntProgress(value=0, max=482), HTML(value='')))" 272 | ] 273 | }, 274 | "metadata": {}, 275 | "output_type": "display_data" 276 | }, 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "\n" 282 | ] 283 | } 284 | ], 285 | "source": [ 286 | "# generate GT for part A\n", 287 | "data_root = '/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/part_A/'\n", 288 | "img_pathes = glob.glob(f'{data_root}*/images/*.jpg')\n", 289 | "map_out_folder = 'maps_adaptive_kernel/'\n", 290 | "min_sigma = 2 ## can be set 0\n", 291 | "method = 1\n", 292 | "\n", 293 | "for full_img_path in tqdm_notebook(img_pathes):\n", 294 | " data_folder, img_path = full_img_path.split('images')\n", 295 | " mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_')\n", 296 | " \n", 297 | " # load img and map\n", 298 | " img = Image.open(full_img_path)\n", 299 | " width, height = img.size\n", 300 | " gt_points = get_gt_dots(mat_path, height, width)\n", 301 | " \n", 302 | " distances = distances_dict[full_img_path]\n", 303 | " density_map = gaussian_filter_density(gt_points, height, width, distances, kernels_dict, min_sigma=min_sigma, method=method)\n", 304 | " \n", 305 | " curr_map_out_folder = data_folder + map_out_folder\n", 306 | " gt_out_path = curr_map_out_folder + img_path.strip('/').replace('.jpg', '.h5')\n", 307 | " \n", 308 | "# #plt.imshow(img)\n", 309 | "# plt.imshow(density_map, alpha=1)\n", 310 | "# plt.show()\n", 311 | "# break\n", 312 | " if not os.path.isdir(curr_map_out_folder):\n", 313 | " print('creating ' + curr_map_out_folder)\n", 314 | " os.makedirs(curr_map_out_folder)\n", 315 | " save_computed_density(density_map, gt_out_path)" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 6, 321 | "metadata": {}, 322 | "outputs": [ 323 | { 324 | "data": { 325 | "application/vnd.jupyter.widget-view+json": { 326 | "model_id": "61b63f97f03146bba6907cddfda42e04", 327 | "version_major": 2, 328 | "version_minor": 0 329 | }, 330 | "text/plain": [ 331 | "HBox(children=(IntProgress(value=0, max=716), HTML(value='')))" 332 | ] 333 | }, 334 | "metadata": {}, 335 | "output_type": "display_data" 336 | }, 337 | { 338 | "name": "stdout", 339 | "output_type": "stream", 340 | "text": [ 341 | "\n" 342 | ] 343 | } 344 | ], 345 | "source": [ 346 | "# generate GT for part B\n", 347 | "data_root = '/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/part_B/'\n", 348 | "img_pathes = glob.glob(f'{data_root}*/images/*.jpg')\n", 349 | "map_out_folder = 'maps_fixed_kernel/'\n", 350 | "min_sigma = 2\n", 351 | "method = 3\n", 352 | "const_sigma=15\n", 353 | "\n", 354 | "for full_img_path in tqdm_notebook(img_pathes):\n", 355 | " data_folder, img_path = full_img_path.split('images')\n", 356 | " mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_')\n", 357 | " \n", 358 | " # load img and map\n", 359 | " img = Image.open(full_img_path)\n", 360 | " width, height = img.size\n", 361 | " gt_points = get_gt_dots(mat_path, height, width)\n", 362 | " \n", 363 | " distances = distances_dict[full_img_path]\n", 364 | " density_map = gaussian_filter_density(gt_points, height, width, distances, kernels_dict, min_sigma=min_sigma, method=method,const_sigma=const_sigma)\n", 365 | " \n", 366 | " curr_map_out_folder = data_folder + map_out_folder\n", 367 | " gt_out_path = curr_map_out_folder + img_path.strip('/').replace('.jpg', '.h5')\n", 368 | " \n", 369 | "# #plt.imshow(img)\n", 370 | "# plt.imshow(density_map, alpha=1)\n", 371 | "# plt.show()\n", 372 | "# break\n", 373 | " if not os.path.isdir(curr_map_out_folder):\n", 374 | " print('creating ' + curr_map_out_folder)\n", 375 | " os.makedirs(curr_map_out_folder)\n", 376 | " save_computed_density(density_map, gt_out_path)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 7, 382 | "metadata": {}, 383 | "outputs": [ 384 | { 385 | "data": { 386 | "image/png": "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\n", 387 | "text/plain": [ 388 | "
" 389 | ] 390 | }, 391 | "metadata": { 392 | "needs_background": "light" 393 | }, 394 | "output_type": "display_data" 395 | } 396 | ], 397 | "source": [ 398 | "plt.imshow(img)\n", 399 | "plt.imshow(density_map, alpha=0.75)\n", 400 | "plt.show()" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": null, 406 | "metadata": {}, 407 | "outputs": [], 408 | "source": [] 409 | } 410 | ], 411 | "metadata": { 412 | "kernelspec": { 413 | "display_name": "Python 3", 414 | "language": "python", 415 | "name": "python3" 416 | }, 417 | "language_info": { 418 | "codemirror_mode": { 419 | "name": "ipython", 420 | "version": 3 421 | }, 422 | "file_extension": ".py", 423 | "mimetype": "text/x-python", 424 | "name": "python", 425 | "nbconvert_exporter": "python", 426 | "pygments_lexer": "ipython3", 427 | "version": "3.6.5" 428 | } 429 | }, 430 | "nbformat": 4, 431 | "nbformat_minor": 2 432 | } 433 | -------------------------------------------------------------------------------- /make_ShanghaiTech.py: -------------------------------------------------------------------------------- 1 | import os 2 | import cv2 3 | import glob 4 | import h5py 5 | import scipy 6 | import pickle 7 | import numpy as np 8 | from PIL import Image 9 | import scipy.io as io 10 | from itertools import islice 11 | from tqdm import tqdm 12 | from matplotlib import pyplot as plt 13 | from sortedcontainers import SortedDict 14 | from scipy.ndimage.filters import gaussian_filter 15 | 16 | 17 | def get_img_pathes(path_sets): 18 | """ 19 | Return all images from all pathes in 'path_sets' 20 | """ 21 | img_pathes = [] 22 | for path in path_sets: 23 | for img_path in glob.glob(os.path.join(path, '*.jpg')): 24 | img_pathes.append(img_path) 25 | return img_pathes 26 | 27 | 28 | def save_computed_density(density_map, out_path): 29 | """ 30 | Save density map to h5py format 31 | """ 32 | with h5py.File(out_path, 'w') as hf: 33 | hf['density'] = density_map 34 | 35 | 36 | def compute_sigma(gt_count, distance=None, min_sigma=1, method=1, fixed_sigma=15): 37 | """ 38 | Compute sigma for gaussian kernel with different methods : 39 | * method = 1 : sigma = (sum of distance to 3 nearest neighbors) / 10 40 | * method = 2 : sigma = distance to nearest neighbor 41 | * method = 3 : sigma = fixed value 42 | ** if sigma lower than threshold 'min_sigma', then 'min_sigma' will be used 43 | ** in case of one point on the image sigma = 'fixed_sigma' 44 | """ 45 | if gt_count > 1 and distance is not None: 46 | if method == 1: 47 | sigma = np.mean(distance[1:4])*0.1 48 | elif method == 2: 49 | sigma = distance[1] 50 | elif method == 3: 51 | sigma = fixed_sigma 52 | else: 53 | sigma = fixed_sigma 54 | if sigma < min_sigma: 55 | sigma = min_sigma 56 | return sigma 57 | 58 | 59 | def find_closest_key(sorted_dict, key): 60 | """ 61 | Find closest key in sorted_dict to 'key' 62 | """ 63 | keys = list(islice(sorted_dict.irange(minimum=key), 1)) 64 | keys.extend(islice(sorted_dict.irange(maximum=key, reverse=True), 1)) 65 | return min(keys, key=lambda k: abs(key - k)) 66 | 67 | 68 | def gaussian_filter_density(non_zero_points, map_h, map_w, distances=None, kernels_dict=None, min_sigma=2, method=1, const_sigma=15): 69 | """ 70 | Fast gaussian filter implementation : using precomputed distances and kernels 71 | """ 72 | gt_count = non_zero_points.shape[0] 73 | density_map = np.zeros((map_h, map_w), dtype=np.float32) 74 | 75 | for i in range(gt_count): 76 | point_y, point_x = non_zero_points[i] 77 | sigma = compute_sigma(gt_count, distances[i], min_sigma=min_sigma, method=method, fixed_sigma=const_sigma) 78 | closest_sigma = find_closest_key(kernels_dict, sigma) 79 | kernel = kernels_dict[closest_sigma] 80 | full_kernel_size = kernel.shape[0] 81 | kernel_size = full_kernel_size // 2 82 | 83 | min_img_x = max(0, point_x-kernel_size) 84 | min_img_y = max(0, point_y-kernel_size) 85 | max_img_x = min(point_x+kernel_size+1, map_h - 1) 86 | max_img_y = min(point_y+kernel_size+1, map_w - 1) 87 | 88 | kernel_x_min = kernel_size - point_x if point_x <= kernel_size else 0 89 | kernel_y_min = kernel_size - point_y if point_y <= kernel_size else 0 90 | kernel_x_max = kernel_x_min + max_img_x - min_img_x 91 | kernel_y_max = kernel_y_min + max_img_y - min_img_y 92 | 93 | density_map[min_img_x:max_img_x, min_img_y:max_img_y] += kernel[kernel_x_min:kernel_x_max, kernel_y_min:kernel_y_max] 94 | return density_map 95 | 96 | 97 | def get_gt_dots(mat_path, img_height, img_width): 98 | """ 99 | Load Matlab file with ground truth labels and save it to numpy array. 100 | ** cliping is needed to prevent going out of the array 101 | """ 102 | mat = io.loadmat(mat_path) 103 | gt = mat["image_info"][0,0][0,0][0].astype(np.float32).round().astype(int) 104 | gt[:,0] = gt[:,0].clip(0, img_width - 1) 105 | gt[:,1] = gt[:,1].clip(0, img_height - 1) 106 | return gt 107 | 108 | 109 | def set_circles_on_img(image, bbox_list, circle_size=2): 110 | """ 111 | Set circles on images at centers of bboxes in bbox_list 112 | """ 113 | for bbox in bbox_list: 114 | cv2.circle(image, (bbox[0], bbox[1]), circle_size, (255, 0, 0), -1) 115 | return image 116 | 117 | 118 | def generate_gaussian_kernels(out_kernels_path='gaussian_kernels.pkl', round_decimals = 3, sigma_threshold = 4, sigma_min=0, sigma_max=20, num_sigmas=801): 119 | """ 120 | Computing gaussian filter kernel for sigmas in linspace(sigma_min, sigma_max, num_sigmas) and saving 121 | them to dict. 122 | """ 123 | kernels_dict = dict() 124 | sigma_space = np.linspace(sigma_min, sigma_max, num_sigmas) 125 | for sigma in tqdm(sigma_space): 126 | sigma = np.round(sigma, decimals=round_decimals) 127 | kernel_size = np.ceil(sigma*sigma_threshold).astype(np.int) 128 | 129 | img_shape = (kernel_size*2+1, kernel_size*2+1) 130 | img_center = (img_shape[0]//2, img_shape[1]//2) 131 | 132 | arr = np.zeros(img_shape) 133 | arr[img_center] = 1 134 | 135 | arr = scipy.ndimage.filters.gaussian_filter(arr, sigma, mode='constant') 136 | kernel = arr / arr.sum() 137 | kernels_dict[sigma] = kernel 138 | 139 | print(f'Computed {len(sigma_space)} gaussian kernels. Saving them to {out_kernels_path}') 140 | 141 | with open(out_kernels_path, 'wb') as f: 142 | pickle.dump(kernels_dict, f) 143 | 144 | 145 | def compute_distances(out_dist_path='distances_dict.pkl', Shanghai_root_path='./', n_neighbors = 4, leafsize=1024): 146 | distances_dict = dict() 147 | full_img_pathes = glob.glob(f'{Shanghai_root_path}*/*/images/*.jpg') 148 | 149 | for full_img_path in tqdm(full_img_pathes): 150 | mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_') 151 | 152 | img = plt.imread(full_img_path) 153 | non_zero_points = get_gt_dots(mat_path, *img.shape[0:2]) 154 | 155 | tree = scipy.spatial.KDTree(non_zero_points.copy(), leafsize=leafsize) # build kdtree 156 | distances, _ = tree.query(non_zero_points, k=n_neighbors) # query kdtree 157 | 158 | distances_dict[full_img_path] = distances 159 | 160 | print(f'Distances computed for {len(full_img_pathes)}. Saving them to {out_dist_path}') 161 | 162 | with open(out_dist_path, 'wb') as f: 163 | pickle.dump(distances_dict, f) 164 | 165 | 166 | precomputed_kernels_path = 'gaussian_kernels.pkl' 167 | 168 | # uncomment to generate and save dict with kernel sizes 169 | generate_gaussian_kernels(precomputed_kernels_path, round_decimals=3, sigma_threshold=4, sigma_min=0, sigma_max=20, num_sigmas=801) 170 | 171 | with open(precomputed_kernels_path, 'rb') as f: 172 | kernels_dict = pickle.load(f) 173 | kernels_dict = SortedDict(kernels_dict) 174 | 175 | 176 | precomputed_distances_path = 'distances_dict.pkl' 177 | 178 | # uncomment to generate and save dict with distances 179 | compute_distances(out_dist_path=precomputed_distances_path, Shanghai_root_path='/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/') 180 | 181 | with open(precomputed_distances_path, 'rb') as f: 182 | distances_dict = pickle.load(f) 183 | 184 | 185 | # generate GT for part A 186 | data_root = '/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/part_A/' 187 | img_pathes = glob.glob(f'{data_root}*/images/*.jpg') 188 | map_out_folder = 'maps_adaptive_kernel/' 189 | min_sigma = 2 ## can be set 0 190 | method = 1 191 | 192 | for full_img_path in tqdm(img_pathes): 193 | data_folder, img_path = full_img_path.split('images') 194 | mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_') 195 | 196 | # load img and map 197 | img = Image.open(full_img_path) 198 | width, height = img.size 199 | gt_points = get_gt_dots(mat_path, height, width) 200 | 201 | distances = distances_dict[full_img_path] 202 | density_map = gaussian_filter_density(gt_points, height, width, distances, kernels_dict, min_sigma=min_sigma, method=method) 203 | 204 | curr_map_out_folder = data_folder + map_out_folder 205 | gt_out_path = curr_map_out_folder + img_path.strip('/').replace('.jpg', '.h5') 206 | 207 | # #plt.imshow(img) 208 | # plt.imshow(density_map, alpha=1) 209 | # plt.show() 210 | # break 211 | if not os.path.isdir(curr_map_out_folder): 212 | print('creating ' + curr_map_out_folder) 213 | os.makedirs(curr_map_out_folder) 214 | save_computed_density(density_map, gt_out_path) 215 | 216 | 217 | # generate GT for part B 218 | data_root = '/home/vladislav.leketush/ssd_data/Crowd_data/ShanghaiTech/ShanghaiTech/part_B/' 219 | img_pathes = glob.glob(f'{data_root}*/images/*.jpg') 220 | map_out_folder = 'maps_fixed_kernel/' 221 | min_sigma = 2 222 | method = 3 223 | const_sigma=15 224 | 225 | for full_img_path in tqdm(img_pathes): 226 | data_folder, img_path = full_img_path.split('images') 227 | mat_path = full_img_path.replace('.jpg','.mat').replace('images','ground-truth').replace('IMG_','GT_IMG_') 228 | 229 | # load img and map 230 | img = Image.open(full_img_path) 231 | width, height = img.size 232 | gt_points = get_gt_dots(mat_path, height, width) 233 | 234 | distances = distances_dict[full_img_path] 235 | density_map = gaussian_filter_density(gt_points, height, width, distances, kernels_dict, min_sigma=min_sigma, method=method,const_sigma=const_sigma) 236 | 237 | curr_map_out_folder = data_folder + map_out_folder 238 | gt_out_path = curr_map_out_folder + img_path.strip('/').replace('.jpg', '.h5') 239 | 240 | # #plt.imshow(img) 241 | # plt.imshow(density_map, alpha=1) 242 | # plt.show() 243 | # break 244 | if not os.path.isdir(curr_map_out_folder): 245 | print('creating ' + curr_map_out_folder) 246 | os.makedirs(curr_map_out_folder) 247 | save_computed_density(density_map, gt_out_path) 248 | 249 | 250 | plt.imshow(img) 251 | plt.imshow(density_map, alpha=0.75) 252 | plt.show() 253 | 254 | 255 | 256 | 257 | 258 | --------------------------------------------------------------------------------